mitkExtractSliceFilter.h

Go to the documentation of this file.

/*===================================================================

The Medical Imaging Interaction Toolkit (MITK)

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

===================================================================*/

#ifndef mitkExtractSliceFilter_h_Included
#define mitkExtractSliceFilter_h_Included

#include "MitkCoreExports.h"
#include "mitkImageToImageFilter.h"

#include <vtkAbstractTransform.h>
#include <vtkImageData.h>
#include <vtkImageReslice.h>
#include <vtkMatrix4x4.h>
#include <vtkPoints.h>
#include <vtkSmartPointer.h>
#include <vtkTransform.h>

namespace mitk
{
  class MITKCORE_EXPORT ExtractSliceFilter : public ImageToImageFilter
  {
  public:
    mitkClassMacro(ExtractSliceFilter, ImageToImageFilter);
    itkFactorylessNewMacro(Self) itkCloneMacro(Self)

      mitkNewMacro1Param(Self, vtkImageReslice *);

    void SetWorldGeometry(const PlaneGeometry *geometry)
    {
      this->m_WorldGeometry = geometry;
      this->Modified();
    }

    void SetTimeStep(unsigned int timestep) { m_TimeStep = timestep; }
    unsigned int GetTimeStep() { return m_TimeStep; }

    void SetComponent(unsigned int component) { m_Component = component; }

    void SetResliceTransformByGeometry(const BaseGeometry *transform) { this->m_ResliceTransform = transform; }
    void SetInPlaneResampleExtentByGeometry(bool inPlaneResampleExtentByGeometry)
    {
      this->m_InPlaneResampleExtentByGeometry = inPlaneResampleExtentByGeometry;
    }

    void SetOutputDimensionality(unsigned int dimension) { this->m_OutputDimension = dimension; }
    void SetOutputSpacingZDirection(double zSpacing) { this->m_ZSpacing = zSpacing; }
    void SetOutputExtentZDirection(int zMin, int zMax)
    {
      this->m_ZMin = zMin;
      this->m_ZMax = zMax;
    }

    bool GetClippedPlaneBounds(double bounds[6]);

    bool GetClippedPlaneBounds(const BaseGeometry *boundingGeometry,
                               const PlaneGeometry *planeGeometry,
                               double *bounds);

    mitk::ScalarType *GetOutputSpacing();

    vtkImageData *GetVtkOutput()
    {
      m_VtkOutputRequested = true;
      return m_Reslicer->GetOutput();
    }

    void SetVtkOutputRequest(bool isRequested) { m_VtkOutputRequested = isRequested; }
    vtkMatrix4x4 *GetResliceAxes() { return this->m_Reslicer->GetResliceAxes(); }
    void SetBackgroundLevel(double backgroundLevel) { m_BackgroundLevel = backgroundLevel; }
    enum ResliceInterpolation
    {
      RESLICE_NEAREST = 0,
      RESLICE_LINEAR = 1,
      RESLICE_CUBIC = 3
    };

    void SetInterpolationMode(ExtractSliceFilter::ResliceInterpolation interpolation)
    {
      this->m_InterpolationMode = interpolation;
    }

  protected:
    ExtractSliceFilter(vtkImageReslice *reslicer = nullptr);
    virtual ~ExtractSliceFilter();

    virtual void GenerateData() override;
    virtual void GenerateOutputInformation() override;
    virtual void GenerateInputRequestedRegion() override;

    const PlaneGeometry *m_WorldGeometry;
    vtkSmartPointer<vtkImageReslice> m_Reslicer;

    unsigned int m_TimeStep;

    unsigned int m_OutputDimension;

    double m_ZSpacing;

    int m_ZMin;

    int m_ZMax;

    ResliceInterpolation m_InterpolationMode;

    BaseGeometry::ConstPointer m_ResliceTransform;

    bool m_InPlaneResampleExtentByGeometry; // Resampling grid corresponds to:  false->image    true->worldgeometry

    mitk::ScalarType *m_OutPutSpacing;

    bool m_VtkOutputRequested;

    double m_BackgroundLevel;

    unsigned int m_Component;
  };
}

#endif // mitkExtractSliceFilter_h_Included