mitkExtractSliceFilter.h

Go to the documentation of this file.

/*============================================================================
 
The Medical Imaging Interaction Toolkit (MITK)
 
Copyright (c) German Cancer Research Center (DKFZ)
All rights reserved.
 
Use of this source code is governed by a 3-clause BSD license that can be
found in the LICENSE file.
 
============================================================================*/
 
#ifndef mitkExtractSliceFilter_h
#define mitkExtractSliceFilter_h
 
#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)
    {
      if (geometry != m_WorldGeometry)
      {
        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);
 
    ~ExtractSliceFilter() override;
 
    void GenerateData() override;
 
    void GenerateOutputInformation() override;
 
    void GenerateInputRequestedRegion() override;
 
    PlaneGeometry::ConstPointer 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;
 
    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;
 
  private:
    BaseGeometry::ConstPointer m_ResliceTransform;
    /* Axis vectors of the relevant geometry. Set in GenerateOutputInformation() and also used in GenerateData().*/
    Vector3D m_Right, m_Bottom;
    /* Bounds of the relevant plane. Set in GenerateOutputInformation() and also used in GenerateData().*/
    int m_XMin, m_XMax, m_YMin, m_YMax;
 
  };
}
 
#endif