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_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)
    {
      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 // mitkExtractSliceFilter_h_Included