mitkRegEvaluationMapper2D.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 mitkRegEvaluationMapper2D_h
#define mitkRegEvaluationMapper2D_h
 
//MatchPoint
#include <mapRegistration.h>
#include <mitkRegEvaluationObject.h>
 
//MITK
#include <mitkCommon.h>
 
//MITK Rendering
#include <mitkBaseRenderer.h>
#include <mitkVtkMapper.h>
#include <mitkExtractSliceFilter.h>
 
//VTK
#include <vtkSmartPointer.h>
#include <vtkPropAssembly.h>
 
//MITK
#include <MitkMatchPointRegistrationExports.h>
 
class vtkActor;
class vtkPolyDataMapper;
class vtkPlaneSource;
class vtkImageData;
class vtkLookupTable;
class vtkImageExtractComponents;
class vtkImageLuminance;
class vtkImageReslice;
class vtkImageChangeInformation;
class vtkPoints;
class vtkMitkThickSlicesFilter;
class vtkPolyData;
class vtkMitkApplyLevelWindowToRGBFilter;
class vtkMitkLevelWindowFilter;
 
namespace mitk {
 
class MITKMATCHPOINTREGISTRATION_EXPORT RegEvaluationMapper2D : public VtkMapper
{
 
public:
  mitkClassMacro( RegEvaluationMapper2D,VtkMapper );
 
  itkFactorylessNewMacro(Self);
  itkCloneMacro(Self);
 
  const mitk::DataNode* GetTargetNode(void);
  const mitk::DataNode* GetMovingNode(void);
  const mitk::Image *GetTargetImage(void);
  const mitk::Image *GetMovingImage(void);
  const mitk::MAPRegistrationWrapper *GetRegistration(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 MITKMATCHPOINTREGISTRATION_EXPORT LocalStorage : public mitk::Mapper::BaseLocalStorage
  {
  public:
    vtkSmartPointer<vtkActor> m_Actor;
 
    vtkSmartPointer<vtkPropAssembly> m_Actors;
    vtkSmartPointer<vtkPolyDataMapper> m_Mapper;
    vtkSmartPointer<vtkImageData> m_EvaluationImage;
 
    vtkSmartPointer<vtkPolyData> m_EmptyPolyData;
    vtkSmartPointer<vtkPlaneSource> m_Plane;
    vtkSmartPointer<vtkTexture> m_Texture;
    vtkSmartPointer<vtkLookupTable> m_ColorLookupTable;
    vtkSmartPointer<vtkLookupTable> m_DefaultLookupTable;
    mitk::ExtractSliceFilter::Pointer m_Reslicer;
 
    mitk::Image::Pointer m_slicedTargetImage;
    mitk::Image::Pointer m_slicedMappedImage;
 
    itk::TimeStamp m_LastUpdateTime;
 
    mitk::ScalarType* m_mmPerPixel;
 
    vtkSmartPointer<vtkMitkLevelWindowFilter> m_TargetLevelWindowFilter;
 
    vtkSmartPointer<vtkMitkLevelWindowFilter> m_MappedLevelWindowFilter;
 
    vtkSmartPointer<vtkImageExtractComponents> m_TargetExtractFilter;
    vtkSmartPointer<vtkImageExtractComponents> m_MappedExtractFilter;
 
    vtkSmartPointer<vtkImageLuminance> m_TargetLuminanceFilter;
    vtkSmartPointer<vtkImageLuminance> m_MappedLuminanceFilter;
 
    vtkAlgorithmOutput* m_TargetScalarOutput = nullptr;
    vtkAlgorithmOutput* m_MappedScalarOutput = nullptr;
 
    vtkSmartPointer<vtkImageExtractComponents> m_TargetColorExtractFilter;
    vtkSmartPointer<vtkImageExtractComponents> m_MappedColorExtractFilter;
 
    vtkAlgorithmOutput* m_TargetColorOutput = nullptr;
    vtkAlgorithmOutput* m_MappedColorOutput = nullptr;
 
    LocalStorage();
    ~LocalStorage() override;
  };
 
  mitk::LocalStorageHandler<LocalStorage> m_LSH;
 
  LocalStorage* GetLocalStorage(mitk::BaseRenderer* renderer);
 
  static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = nullptr, bool overwrite = false);
 
protected:
  void TransformActor(mitk::BaseRenderer* renderer);
 
  void GeneratePlane(mitk::BaseRenderer* renderer, double planeBounds[6]);
 
  RegEvaluationMapper2D();
  ~RegEvaluationMapper2D() override;
 
  void GenerateDataForRenderer(mitk::BaseRenderer *renderer) override;
 
  void PrepareContour( mitk::DataNode* datanode, LocalStorage * localStorage );
 
  void PrepareDifference( LocalStorage * localStorage );
 
  void PrepareWipe(mitk::DataNode* datanode, LocalStorage * localStorage, const Point2D& currentIndex2D);
 
  void PrepareCheckerBoard( mitk::DataNode* datanode, LocalStorage * localStorage );
 
  void PrepareColorBlend( LocalStorage * localStorage );
 
  void PrepareBlend( mitk::DataNode* datanode, LocalStorage * localStorage );
 
  float CalculateLayerDepth(mitk::BaseRenderer* renderer);
 
  void ApplyLookuptable(mitk::BaseRenderer* renderer, const mitk::DataNode* dataNode, vtkMitkLevelWindowFilter* levelFilter);
 
  void ApplyLevelWindow(mitk::BaseRenderer *renderer, const mitk::DataNode* dataNode, vtkMitkLevelWindowFilter* levelFilter);
 
  void ApplyOpacity( mitk::BaseRenderer* renderer );
 
  bool RenderingGeometryIntersectsImage( const PlaneGeometry* renderingGeometry, SlicedGeometry3D* imageGeometry );
};
 
} // namespace mitk
 
#endif