mitkGeometry2DDataVtkMapper3D.h

Go to the documentation of this file.

/*=========================================================================

Program:   Medical Imaging & Interaction Toolkit
Language:  C++
Date:      $Date$
Version:   $Revision$

Copyright (c) German Cancer Research Center, Division of Medical and
Biological Informatics. All rights reserved.
See MITKCopyright.txt or https://www.mitk.org/copyright.html for details.

This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notices for more information.

=========================================================================*/


#ifndef MITKGEOMETRY2DDATAVTKMAPPER3D_H_HEADER_INCLUDED_C196C71F
#define MITKGEOMETRY2DDATAVTKMAPPER3D_H_HEADER_INCLUDED_C196C71F

#include "mitkCommon.h"
#include "mitkVtkMapper3D.h"
#include "mitkDataStorage.h"
#include "mitkGeometry2DDataToSurfaceFilter.h"
#include "mitkWeakPointer.h"

#include <vtkSystemIncludes.h>
#include <vtkCleanPolyData.h>

class vtkActor;
class vtkPolyDataMapper;
class vtkDataSetMapper;
class vtkLookupTable;
class vtkAssembly;
class vtkFeatureEdges;
class vtkTubeFilter;
class vtkTransformPolyDataFilter;
class vtkHedgeHog;

namespace mitk {

class Geometry2DData;
class BaseRenderer;
class ImageMapperGL2D;
class DataStorage;

class MITK_CORE_EXPORT Geometry2DDataVtkMapper3D : public VtkMapper3D
{
public:
  mitkClassMacro(Geometry2DDataVtkMapper3D, VtkMapper3D);

  itkNewMacro(Geometry2DDataVtkMapper3D);

  virtual vtkProp *GetVtkProp(mitk::BaseRenderer *renderer);
  virtual void UpdateVtkTransform(mitk::BaseRenderer *renderer);

  virtual const Geometry2DData *GetInput();

  virtual void SetDataStorageForTexture(mitk::DataStorage* storage);

protected:

  Geometry2DDataVtkMapper3D();

  virtual ~Geometry2DDataVtkMapper3D();

  virtual void GenerateData(BaseRenderer* renderer);

  typedef std::multimap< int, vtkActor * > LayerSortedActorList;

  void ProcessNode( DataNode * node, BaseRenderer* renderer, Surface * surface, LayerSortedActorList &layerSortedActors );

  /*
   * \brief Construct an extended lookup table from the given one.
   *
   * In order to overlay differently sized images over each other, it is
   * necessary to have a special translucent value, so that the empty
   * surroundings of the smaller image do not occlude the bigger image.
   *
   * The smallest possible short (-32768) is used for this. Due to the
   * implementation of vtkLookupTable, the lookup table needs to be extended
   * so that this value is included. Entries between -32768 and the actual
   * table minimum will be set to the lowest entry in the input lookup table.
   * From this point onward, the input lookup is just copied into the output
   * lookup table.
   *
   * See also mitk::ImageMapperGL2D, where -32768 is defined as BackgroundLevel
   * for resampling.
   *
   * NOTE: This method is currently not used; to make sure that the plane is
   * not rendered with translucent "holes", a black background plane is first
   * rendered under all other planes.
   */
  //virtual void BuildPaddedLookupTable(
  //  vtkLookupTable *inputLookupTable, vtkLookupTable *outputLookupTable,
  //  vtkFloatingPointType min, vtkFloatingPointType max );

  int FindPowerOfTwo( int i );

  void ImageMapperDeletedCallback( itk::Object *caller, const itk::EventObject &event );

  vtkAssembly *m_Prop3DAssembly;

  vtkAssembly *m_ImageAssembly;

  Geometry2DDataToSurfaceFilter::Pointer m_SurfaceCreator;

  BoundingBox::Pointer m_SurfaceCreatorBoundingBox;

  BoundingBox::PointsContainer::Pointer m_SurfaceCreatorPointsContainer;

  vtkFeatureEdges *m_Edges;

  vtkTransformPolyDataFilter *m_EdgeTransformer;

  vtkTubeFilter *m_EdgeTuber;

  vtkPolyDataMapper *m_EdgeMapper;

  vtkActor *m_EdgeActor;

  vtkPolyDataMapper *m_BackgroundMapper;

  vtkActor *m_BackgroundActor;

  vtkTransformPolyDataFilter* m_NormalsTransformer;

  vtkPolyDataMapper* m_FrontNormalsMapper;
  vtkPolyDataMapper* m_BackNormalsMapper;

  vtkHedgeHog* m_FrontHedgeHog;
  vtkHedgeHog* m_BackHedgeHog;

  vtkActor* m_FrontNormalsActor;
  vtkActor* m_BackNormalsActor;

  vtkCleanPolyData *m_Cleaner;

  bool m_DisplayNormals;

  bool m_ColorTwoSides;

  bool m_InvertNormals;

  bool m_NormalsActorAdded;

  mitk::WeakPointer<mitk::DataStorage> m_DataStorage;

  vtkLookupTable *m_DefaultLookupTable;

  class MITK_CORE_EXPORT ActorInfo
  {
  public:
    vtkActor * m_Actor;
    // we do not need a smart-pointer, because we delete our
    // connection, when the referenced mapper is destroyed
    itk::Object* m_Sender;
    unsigned long m_ObserverID;

    void Initialize(vtkActor* actor, itk::Object* sender, itk::Command* command);

    ActorInfo();
    ~ActorInfo();
  };

  typedef std::map< ImageMapperGL2D *, ActorInfo > ActorList;
  ActorList m_ImageActors;

  struct LookupTableProperties
  {
    LookupTableProperties()
    : LookupTableSource( NULL ),
      windowMin( 0.0 ),
      windowMax( 4096.0 )
    {}
    vtkLookupTable *LookupTableSource;
    vtkFloatingPointType windowMin;
    vtkFloatingPointType windowMax;
  };

  typedef std::map< ImageMapperGL2D *, LookupTableProperties >
    LookupTablePropertiesList;

  LookupTablePropertiesList m_LookupTableProperties;


  // responsiblity to remove the observer upon its destruction
  typedef itk::MemberCommand< Geometry2DDataVtkMapper3D > MemberCommandType;
  MemberCommandType::Pointer m_ImageMapperDeletedCommand;
};
} // namespace mitk
#endif /* MITKGEOMETRY2DDATAVTKMAPPER3D_H_HEADER_INCLUDED_C196C71F */