mitkRegEvaluationMapper2D.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 MITK_REG_EVALUATION_MAPPER_2D_H
#define MITK_REG_EVALUATION_MAPPER_2D_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 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);

  virtual void Update(mitk::BaseRenderer * renderer);

  //### methods of MITK-VTK rendering pipeline
  virtual vtkProp* GetVtkProp(mitk::BaseRenderer* renderer);
  //### 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;

    LocalStorage();
    ~LocalStorage();
  };

  mitk::LocalStorageHandler<LocalStorage> m_LSH;

  LocalStorage* GetLocalStorage(mitk::BaseRenderer* renderer);

  static void SetDefaultProperties(mitk::DataNode* node, mitk::BaseRenderer* renderer = NULL, bool overwrite = false);

protected:
  void TransformActor(mitk::BaseRenderer* renderer);

  void GeneratePlane(mitk::BaseRenderer* renderer, double planeBounds[6]);

  RegEvaluationMapper2D();
  virtual ~RegEvaluationMapper2D();

  virtual void GenerateDataForRenderer(mitk::BaseRenderer *renderer);

  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 Geometry2D* renderingGeometry, SlicedGeometry3D* imageGeometry );
};

} // namespace mitk

#endif /* MITKRegEvaluationMapper2D_H_HEADER_INCLUDED_C10E906E */