mitkImageVtkMapper2D.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 mitkImageVtkMapper2D_h
#define mitkImageVtkMapper2D_h
 
// MITK
#include <mitkCommon.h>
 
// MITK Rendering
#include "mitkBaseRenderer.h"
#include "mitkExtractSliceFilter.h"
#include "mitkVtkMapper.h"
 
// VTK
#include <vtkPropAssembly.h>
#include <vtkSmartPointer.h>
 
class vtkActor;
class vtkPolyDataMapper;
class vtkPlaneSource;
class vtkImageData;
class vtkLookupTable;
class vtkImageExtractComponents;
class vtkImageReslice;
class vtkImageChangeInformation;
class vtkPoints;
class vtkMitkThickSlicesFilter;
class vtkPolyData;
class vtkMitkApplyLevelWindowToRGBFilter;
class vtkMitkLevelWindowFilter;
 
namespace mitk
{
  class MITKCORE_EXPORT ImageVtkMapper2D : public VtkMapper
  {
  public:
    mitkClassMacro(ImageVtkMapper2D, VtkMapper);
 
    itkFactorylessNewMacro(Self);
    itkCloneMacro(Self);
 
      const mitk::Image *GetInput(void);
 
    void Update(mitk::BaseRenderer *renderer) override;
 
    //### methods of MITK-VTK rendering pipeline
    vtkProp *GetVtkProp(mitk::BaseRenderer *renderer) override;
    //### end of methods of MITK-VTK rendering pipeline
 
    class MITKCORE_EXPORT LocalStorage : public mitk::Mapper::BaseLocalStorage
    {
    public:
      vtkSmartPointer<vtkActor> m_ImageActor;
      vtkSmartPointer<vtkActor> m_ShadowOutlineActor;
 
      vtkSmartPointer<vtkPropAssembly> m_Actors;
      vtkSmartPointer<vtkPropAssembly> m_EmptyActors;
      vtkProp* m_PublicActors = nullptr;
 
      vtkSmartPointer<vtkPolyDataMapper> m_Mapper;
      vtkSmartPointer<vtkImageExtractComponents> m_VectorComponentExtractor;
      vtkSmartPointer<vtkImageData> m_ReslicedImage;
      vtkSmartPointer<vtkPolyData> m_EmptyPolyData;
      vtkSmartPointer<vtkPlaneSource> m_Plane;
      vtkSmartPointer<vtkTexture> m_Texture;
      vtkSmartPointer<vtkLookupTable> m_DefaultLookupTable;
      vtkSmartPointer<vtkLookupTable> m_BinaryLookupTable;
      vtkSmartPointer<vtkLookupTable> m_ColorLookupTable;
      mitk::ExtractSliceFilter::Pointer m_Reslicer;
      vtkSmartPointer<vtkMitkThickSlicesFilter> m_TSFilter;
      vtkSmartPointer<vtkPolyData> m_OutlinePolyData;
 
      itk::TimeStamp m_LastUpdateTime;
 
      mitk::ScalarType *m_mmPerPixel;
 
      vtkSmartPointer<vtkMitkLevelWindowFilter> m_LevelWindowFilter;
 
      LocalStorage();
      ~LocalStorage() override;
    };
 
    const LocalStorage *GetConstLocalStorage(mitk::BaseRenderer *renderer);
 
    static void SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer = nullptr, bool overwrite = false);
 
    void ApplyRenderingMode(mitk::BaseRenderer *renderer);
 
  protected:
    mitk::LocalStorageHandler<LocalStorage> m_LSH;
 
    LocalStorage* GetLocalStorage(mitk::BaseRenderer* renderer);
 
    void TransformActor(mitk::BaseRenderer *renderer);
 
    void GeneratePlane(mitk::BaseRenderer *renderer, double planeBounds[6]);
 
    template <typename TPixel>
    vtkSmartPointer<vtkPolyData> CreateOutlinePolyData(mitk::BaseRenderer *renderer);
 
    ImageVtkMapper2D();
    ~ImageVtkMapper2D() override;
 
    void GenerateDataForRenderer(mitk::BaseRenderer *renderer) override;
 
    float CalculateLayerDepth(mitk::BaseRenderer *renderer);
 
    void ApplyLookuptable(mitk::BaseRenderer *renderer);
 
    void ApplyColorTransferFunction(mitk::BaseRenderer *renderer);
 
    void ApplyLevelWindow(mitk::BaseRenderer *renderer);
 
    void ApplyColor(mitk::BaseRenderer *renderer);
 
    void ApplyOpacity(mitk::BaseRenderer *renderer);
 
    bool RenderingGeometryIntersectsImage(const PlaneGeometry *renderingGeometry, SlicedGeometry3D *imageGeometry);
 
    void SetToInvalidState(mitk::ImageVtkMapper2D::LocalStorage* localStorage);
  };
 
} // namespace mitk
 
#endif