Vtk-based mapper to display a Geometry2D in a 3D windowUses a Geometry2DDataToSurfaceFilter object to create a vtkPolyData representation of a given Geometry2D instance. Geometry2D may either contain a common flat plane or a curved plane (ThinPlateSplineCurvedGeometry). More...

#include <mitkGeometry2DDataVtkMapper3D.h>

Inheritance diagram for mitk::Geometry2DDataVtkMapper3D:

[legend]

Collaboration diagram for mitk::Geometry2DDataVtkMapper3D:

[legend]

List of all members.

Classes
class	ActorInfo
struct	LookupTableProperties
Public Types
typedef Geometry2DDataVtkMapper3D	Self
typedef VtkMapper3D	Superclass
typedef itk::SmartPointer< Self >	Pointer
typedef itk::SmartPointer < const Self >	ConstPointer
Public Member Functions
virtual const char *	GetClassName () const
virtual vtkProp *	GetVtkProp (mitk::BaseRenderer *renderer)
virtual void	UpdateVtkTransform (mitk::BaseRenderer *renderer)
	Set the vtkTransform of the m_Prop3D for the current time step of renderer.
virtual const Geometry2DData *	GetInput ()
	Get the Geometry2DData to map.
virtual void	SetDataStorageForTexture (mitk::DataStorage *storage)
	All images found when traversing the (sub-) tree starting at iterator which are resliced by an ImageMapperGL2D will be mapped.
Static Public Member Functions
static Pointer	New ()
Protected Types
typedef std::multimap< int, vtkActor * >	LayerSortedActorList
typedef std::map < ImageMapperGL2D *, ActorInfo >	ActorList
	List holding the vtkActor to map the image into 3D for each ImageMapper.
typedef std::map < ImageMapperGL2D *, LookupTableProperties >	LookupTablePropertiesList
typedef itk::MemberCommand < Geometry2DDataVtkMapper3D >	MemberCommandType
Protected Member Functions
	Geometry2DDataVtkMapper3D ()
virtual	~Geometry2DDataVtkMapper3D ()
virtual void	GenerateData (BaseRenderer *renderer)
	Generate the data needed for rendering into renderer.
void	ProcessNode (DataNode node, BaseRenderer renderer, Surface *surface, LayerSortedActorList &layerSortedActors)
int	FindPowerOfTwo (int i)
void	ImageMapperDeletedCallback (itk::Object *caller, const itk::EventObject &event)
Protected Attributes
vtkAssembly *	m_Prop3DAssembly
	general PropAssembly to hold the entire scene
vtkAssembly *	m_ImageAssembly
	PropAssembly to hold the planes.
Geometry2DDataToSurfaceFilter::Pointer	m_SurfaceCreator
BoundingBox::Pointer	m_SurfaceCreatorBoundingBox
BoundingBox::PointsContainer::Pointer	m_SurfaceCreatorPointsContainer
vtkFeatureEdges *	m_Edges
	Edge extractor for tube-shaped frame.
vtkTransformPolyDataFilter *	m_EdgeTransformer
	Filter to apply object transform to the extracted edges.
vtkTubeFilter *	m_EdgeTuber
	Source to create the tube-shaped frame.
vtkPolyDataMapper *	m_EdgeMapper
	Mapper for the tube-shaped frame.
vtkActor *	m_EdgeActor
	Actor for the tube-shaped frame.
vtkPolyDataMapper *	m_BackgroundMapper
	Mapper for black plane background.
vtkActor *	m_BackgroundActor
	Actor for black plane background.
vtkTransformPolyDataFilter *	m_NormalsTransformer
	Transforms the suface before applying the glyph filter.
vtkPolyDataMapper *	m_FrontNormalsMapper
	Mapper for normals representation (thin lines)
vtkPolyDataMapper *	m_BackNormalsMapper
vtkHedgeHog *	m_FrontHedgeHog
	Generates lines for surface normals.
vtkHedgeHog *	m_BackHedgeHog
vtkActor *	m_FrontNormalsActor
	Actor to hold the normals arrows.
vtkActor *	m_BackNormalsActor
vtkCleanPolyData *	m_Cleaner
bool	m_DisplayNormals
	Whether or not to display normals.
bool	m_ColorTwoSides
	Whether to color front and back.
bool	m_InvertNormals
	Whether or not to invert normals.
bool	m_NormalsActorAdded
mitk::WeakPointer < mitk::DataStorage >	m_DataStorage
	The DataStorage defines which part of the data tree is traversed for renderering.
vtkLookupTable *	m_DefaultLookupTable
ActorList	m_ImageActors
LookupTablePropertiesList	m_LookupTableProperties
	List holding some lookup table properties of the previous pass.
MemberCommandType::Pointer	m_ImageMapperDeletedCommand

Detailed Description

Vtk-based mapper to display a Geometry2D in a 3D window

Uses a Geometry2DDataToSurfaceFilter object to create a vtkPolyData representation of a given Geometry2D instance. Geometry2D may either contain a common flat plane or a curved plane (ThinPlateSplineCurvedGeometry).

The vtkPolyData object is then decorated by a colored tube on the edges and by image textures if possible (currently this requires that there is a 2D render window rendering the same geometry as this mapper).

Properties that influence rendering are:

"color": (ColorProperty) Color of the tubed frame.
"xresolution": (FloatProperty) Resolution (=number of tiles) in x direction. Only relevant for ThinPlateSplineCurvedGeometry
"yresolution": (FloatProperty) Resolution (=number of tiles) in y direction. Only relevant for ThinPlateSplineCurvedGeometry
"draw normals 3D": (BoolProperty) If true, a vtkHedgeHog is used to display normals for the generated surface object. Useful to distinguish front and back of a plane. Hedgehogs are colored according to "front color" and "back color"
"color two sides": (BoolProperty) If true, front and back side of the plane are colored differently ("front color" and "back color")
"invert normals": (BoolProperty) Inverts front/back for display.
"front color": (ColorProperty) Color for front side of the plane
"back color": (ColorProperty) Color for back side of the plane

The internal filter pipeline which combines a (sometimes deformed) 2D surface with a nice frame and image textures is illustrated in the following sketch:

Internal filter pipeline

Definition at line 75 of file mitkGeometry2DDataVtkMapper3D.h.

Member Typedef Documentation

typedef std::map< ImageMapperGL2D *, ActorInfo > mitk::Geometry2DDataVtkMapper3D::ActorList [protected]

List holding the vtkActor to map the image into 3D for each ImageMapper.

Definition at line 229 of file mitkGeometry2DDataVtkMapper3D.h.

typedef itk::SmartPointer<const Self> mitk::Geometry2DDataVtkMapper3D::ConstPointer

Reimplemented from mitk::VtkMapper3D.

Definition at line 78 of file mitkGeometry2DDataVtkMapper3D.h.

typedef std::multimap< int, vtkActor * > mitk::Geometry2DDataVtkMapper3D::LayerSortedActorList [protected]

Definition at line 109 of file mitkGeometry2DDataVtkMapper3D.h.

typedef std::map< ImageMapperGL2D *, LookupTableProperties > mitk::Geometry2DDataVtkMapper3D::LookupTablePropertiesList [protected]

Definition at line 245 of file mitkGeometry2DDataVtkMapper3D.h.

typedef itk::MemberCommand< Geometry2DDataVtkMapper3D > mitk::Geometry2DDataVtkMapper3D::MemberCommandType [protected]

Definition at line 252 of file mitkGeometry2DDataVtkMapper3D.h.

typedef itk::SmartPointer<Self> mitk::Geometry2DDataVtkMapper3D::Pointer

Reimplemented from mitk::VtkMapper3D.

Definition at line 78 of file mitkGeometry2DDataVtkMapper3D.h.

typedef Geometry2DDataVtkMapper3D mitk::Geometry2DDataVtkMapper3D::Self

Reimplemented from mitk::VtkMapper3D.

Definition at line 78 of file mitkGeometry2DDataVtkMapper3D.h.

typedef VtkMapper3D mitk::Geometry2DDataVtkMapper3D::Superclass

Reimplemented from mitk::VtkMapper3D.

Definition at line 78 of file mitkGeometry2DDataVtkMapper3D.h.

Constructor & Destructor Documentation

mitk::Geometry2DDataVtkMapper3D::Geometry2DDataVtkMapper3D ( ) [protected]

Definition at line 23 of file mitkGeometry2DDataVtkMapper3D.cpp.

References mitk::Geometry2DDataToSurfaceFilter::New().

{

Geometry2DDataVtkMapper3D::Geometry2DDataVtkMapper3D()
  : m_DisplayNormals(false),
  m_ColorTwoSides(false),
  m_InvertNormals(true),
  m_NormalsActorAdded(false),
  m_DataStorage(NULL)
{
  m_EdgeTuber = vtkTubeFilter::New();
  m_EdgeMapper = vtkPolyDataMapper::New();

  // Disable OGL Displaylist for the "Edge". Workaround for Bug #1787
  // m_EdgeMapper->ImmediateModeRenderingOn();

  m_SurfaceCreator = Geometry2DDataToSurfaceFilter::New();
  m_SurfaceCreatorBoundingBox = BoundingBox::New();
  m_SurfaceCreatorPointsContainer = BoundingBox::PointsContainer::New();
  m_Edges = vtkFeatureEdges::New();

  m_Edges->BoundaryEdgesOn();
  m_Edges->FeatureEdgesOff();
  m_Edges->NonManifoldEdgesOff();
  m_Edges->ManifoldEdgesOff();

  m_EdgeTransformer = vtkTransformPolyDataFilter::New();
  m_NormalsTransformer = vtkTransformPolyDataFilter::New();
  m_EdgeActor = vtkActor::New();
  m_BackgroundMapper = vtkPolyDataMapper::New();
  m_BackgroundActor = vtkActor::New();
  m_Prop3DAssembly = vtkAssembly::New();
  m_ImageAssembly = vtkAssembly::New();

  m_SurfaceCreatorBoundingBox->SetPoints( m_SurfaceCreatorPointsContainer );

  m_Cleaner = vtkCleanPolyData::New();

  m_Cleaner->PieceInvariantOn();
  m_Cleaner->ConvertLinesToPointsOn();
  m_Cleaner->ConvertPolysToLinesOn();
  m_Cleaner->ConvertStripsToPolysOn();
  m_Cleaner->PointMergingOn();

  // Make sure that the FeatureEdge algorithm is initialized with a "valid"
  // (though empty) input
  vtkPolyData *emptyPolyData = vtkPolyData::New();
  m_Cleaner->SetInput( emptyPolyData );
  emptyPolyData->Delete();

  m_Edges->SetInput(m_Cleaner->GetOutput());
  m_EdgeTransformer->SetInput( m_Edges->GetOutput() );

  m_EdgeTuber->SetInput( m_EdgeTransformer->GetOutput() );
  m_EdgeTuber->SetVaryRadiusToVaryRadiusOff();
  m_EdgeTuber->SetNumberOfSides( 12 );
  m_EdgeTuber->CappingOn();

  m_EdgeMapper->SetInput( m_EdgeTuber->GetOutput() );
  m_EdgeMapper->ScalarVisibilityOff();

  m_BackgroundMapper->SetInput(emptyPolyData);
  //  m_BackgroundMapper->ImmediateModeRenderingOn();
  m_EdgeActor->SetMapper( m_EdgeMapper );

  m_BackgroundMapper->SetInput(emptyPolyData);
  m_BackgroundMapper->ImmediateModeRenderingOn();

  m_BackgroundActor->GetProperty()->SetAmbient( 0.5 );
  m_BackgroundActor->GetProperty()->SetColor( 0.0, 0.0, 0.0 );
  m_BackgroundActor->GetProperty()->SetOpacity( 1.0 );
  m_BackgroundActor->SetMapper( m_BackgroundMapper );

  vtkProperty * backfaceProperty = m_BackgroundActor->MakeProperty();
  backfaceProperty->SetColor( 0.0, 0.0, 0.0 );
  m_BackgroundActor->SetBackfaceProperty( backfaceProperty );
  backfaceProperty->Delete();

  m_FrontHedgeHog = vtkHedgeHog::New();
  m_BackHedgeHog  = vtkHedgeHog::New();

  m_FrontNormalsMapper = vtkPolyDataMapper::New();
  m_FrontNormalsMapper->SetInput( m_FrontHedgeHog->GetOutput() );
  m_BackNormalsMapper = vtkPolyDataMapper::New();


  m_Prop3DAssembly->AddPart( m_EdgeActor );

mitk::Geometry2DDataVtkMapper3D::~Geometry2DDataVtkMapper3D ( ) [protected, virtual]

Definition at line 132 of file mitkGeometry2DDataVtkMapper3D.cpp.

{
  m_ImageAssembly->Delete();
  m_Prop3DAssembly->Delete();
  m_EdgeTuber->Delete();
  m_EdgeMapper->Delete();
  m_EdgeTransformer->Delete();
  m_Cleaner->Delete();
  m_Edges->Delete();
  m_NormalsTransformer->Delete();
  m_EdgeActor->Delete();
  m_BackgroundMapper->Delete();

Member Function Documentation

int mitk::Geometry2DDataVtkMapper3D::FindPowerOfTwo ( int i ) [protected]

Definition at line 262 of file mitkGeometry2DDataVtkMapper3D.cpp.

    {
//    *outputPtr++ = *inputPtr++;
//    *outputPtr++ = *inputPtr++;
//    *outputPtr++ = *inputPtr++;
//    *outputPtr++ = *inputPtr++;
//
//    // While filling the padded part of the table, use the default value
//    // (the first value of the input table)
//    if ( i < (tableSize - 256) )
//    {

void mitk::Geometry2DDataVtkMapper3D::GenerateData ( BaseRenderer * renderer ) [protected, virtual]

Generate the data needed for rendering into renderer.

Reimplemented from mitk::Mapper.

Definition at line 294 of file mitkGeometry2DDataVtkMapper3D.cpp.

{
  ImageMapperGL2D *imageMapper = dynamic_cast< ImageMapperGL2D * >( caller );
  if ( (imageMapper != NULL) )
  {
    if ( m_ImageActors.count( imageMapper ) > 0)
    {
      m_ImageActors[imageMapper].m_Sender = NULL; // sender is already destroying itself
      m_ImageActors.erase( imageMapper );
    }
    if ( m_LookupTableProperties.count( imageMapper ) > 0 )
    {
      m_LookupTableProperties[imageMapper].LookupTableSource->Delete();
      m_LookupTableProperties.erase( imageMapper );
    }
  }
}


void Geometry2DDataVtkMapper3D::GenerateData(BaseRenderer* renderer)
{
  SetVtkMapperImmediateModeRendering(m_EdgeMapper);
  SetVtkMapperImmediateModeRendering(m_BackgroundMapper);

  // Remove all actors from the assembly, and re-initialize it with the
  // edge actor
  m_ImageAssembly->GetParts()->RemoveAllItems();

  if ( !this->IsVisible(renderer) )
  {
    // visibility has explicitly to be set in the single actors
    // due to problems when using cell picking:
    // even if the assembly is invisible, the renderer contains
    // references to the assemblies parts. During picking the
    // visibility of each part is checked, and not only for the
    // whole assembly.
    m_ImageAssembly->VisibilityOff();
    m_EdgeActor->VisibilityOff();
    return;
  }

  // visibility has explicitly to be set in the single actors
  // due to problems when using cell picking:
  // even if the assembly is invisible, the renderer contains
  // references to the assemblies parts. During picking the
  // visibility of each part is checked, and not only for the
  // whole assembly.
  m_ImageAssembly->VisibilityOn();
  m_EdgeActor->VisibilityOn();

  Geometry2DData::Pointer input = const_cast< Geometry2DData * >(this->GetInput());

  if (input.IsNotNull() && (input->GetGeometry2D() != NULL))
  {
    SmartPointerProperty::Pointer surfacecreatorprop;
    surfacecreatorprop = dynamic_cast< SmartPointerProperty * >(GetDataNode()->GetProperty("surfacegeometry", renderer));

    if ( (surfacecreatorprop.IsNull())
      || (surfacecreatorprop->GetSmartPointer().IsNull())
      || ((m_SurfaceCreator = dynamic_cast<Geometry2DDataToSurfaceFilter*>(
      surfacecreatorprop->GetSmartPointer().GetPointer())).IsNull() )
      )
    {
      //m_SurfaceCreator = Geometry2DDataToSurfaceFilter::New();
      m_SurfaceCreator->PlaceByGeometryOn();
      surfacecreatorprop = SmartPointerProperty::New( m_SurfaceCreator );
      GetDataNode()->SetProperty("surfacegeometry", surfacecreatorprop);
    }

    m_SurfaceCreator->SetInput(input);

    int res;
    if (GetDataNode()->GetIntProperty("xresolution", res, renderer))
    {
      m_SurfaceCreator->SetXResolution(res);
    }
    if (GetDataNode()->GetIntProperty("yresolution", res, renderer))
    {
      m_SurfaceCreator->SetYResolution(res);
    }

    double tubeRadius = 1.0; // Radius of tubular edge surrounding plane

    // Clip the Geometry2D with the reference geometry bounds (if available)
    if ( input->GetGeometry2D()->HasReferenceGeometry() )
    {
      Geometry3D *referenceGeometry =
        input->GetGeometry2D()->GetReferenceGeometry();

      BoundingBox::PointType boundingBoxMin, boundingBoxMax;
      boundingBoxMin = referenceGeometry->GetBoundingBox()->GetMinimum();
      boundingBoxMax = referenceGeometry->GetBoundingBox()->GetMaximum();

      if ( referenceGeometry->GetImageGeometry() )
      {
        for ( unsigned int i = 0; i < 3; ++i )
        {
          boundingBoxMin[i] -= 0.5;
          boundingBoxMax[i] -= 0.5;
        }
      }

      m_SurfaceCreatorPointsContainer->CreateElementAt( 0 ) = boundingBoxMin;
      m_SurfaceCreatorPointsContainer->CreateElementAt( 1 ) = boundingBoxMax;

      m_SurfaceCreatorBoundingBox->ComputeBoundingBox();

      m_SurfaceCreator->SetBoundingBox( m_SurfaceCreatorBoundingBox );

      tubeRadius = referenceGeometry->GetDiagonalLength() / 450.0;
    }
    else
    {
      // If no reference geometry is available, clip with the current global
      // bounds
      if (m_DataStorage.IsNotNull())
      {
        m_SurfaceCreator->SetBoundingBox(m_DataStorage->ComputeVisibleBoundingBox(NULL, "includeInBoundingBox"));

        tubeRadius = sqrt( m_SurfaceCreator->GetBoundingBox()->GetDiagonalLength2() ) / 450.0;
      }
    }

    // Calculate the surface of the Geometry2D
    m_SurfaceCreator->Update();

    Surface *surface = m_SurfaceCreator->GetOutput();

    // Check if there's something to display, otherwise return
    if ( (surface->GetVtkPolyData() == 0 )
      || (surface->GetVtkPolyData()->GetNumberOfCells() == 0) )
    {
      m_ImageAssembly->VisibilityOff();
      return;
    }

    // add a graphical representation of the surface normals if requested
    DataNode* node = this->GetDataNode();
    node->GetBoolProperty("draw normals 3D", m_DisplayNormals, renderer);
    node->GetBoolProperty("color two sides", m_ColorTwoSides, renderer);
    node->GetBoolProperty("invert normals", m_InvertNormals, renderer);

    if ( m_DisplayNormals || m_ColorTwoSides )
    {
      float frontColor[3] = { 0.0, 0.0, 1.0 };
      node->GetColor( frontColor, renderer, "front color" );
      float backColor[3] = { 1.0, 0.0, 0.0 };
      node->GetColor( backColor, renderer, "back color" );

      if ( m_DisplayNormals )
      {
        m_NormalsTransformer->SetInput( surface->GetVtkPolyData() );
        m_NormalsTransformer->SetTransform(node->GetVtkTransform(this->GetTimestep()) );

        m_FrontHedgeHog->SetInput( m_NormalsTransformer->GetOutput() );
        m_FrontHedgeHog->SetVectorModeToUseNormal();
        m_FrontHedgeHog->SetScaleFactor( m_InvertNormals ? 1.0 : -1.0 );

        m_FrontNormalsActor->GetProperty()->SetColor( frontColor[0], frontColor[1], frontColor[2] );

        m_BackHedgeHog->SetInput( m_NormalsTransformer->GetOutput() );
        m_BackHedgeHog->SetVectorModeToUseNormal();
        m_BackHedgeHog->SetScaleFactor( m_InvertNormals ? -1.0 : 1.0 );

        m_BackNormalsActor->GetProperty()->SetColor( backColor[0], backColor[1], backColor[2] );

        if ( !m_NormalsActorAdded )
        {
          m_Prop3DAssembly->AddPart( m_FrontNormalsActor );
          m_Prop3DAssembly->AddPart( m_BackNormalsActor );
          m_NormalsActorAdded = true;
        }
      }

      if ( m_ColorTwoSides )
      {
        if ( !m_InvertNormals )
        {
          m_BackgroundActor->GetBackfaceProperty()->SetColor( frontColor[0], frontColor[1], frontColor[2] );
          m_BackgroundActor->GetProperty()->SetColor( backColor[0], backColor[1], backColor[2] );
        }
        else
        {
          m_BackgroundActor->GetProperty()->SetColor( frontColor[0], frontColor[1], frontColor[2] );
          m_BackgroundActor->GetBackfaceProperty()->SetColor( backColor[0], backColor[1], backColor[2] );
        }
      }

    }
    else if ( !m_DisplayNormals )
    {
      if ( m_NormalsActorAdded )
      {
        m_Prop3DAssembly->RemovePart( m_FrontNormalsActor );
        m_Prop3DAssembly->RemovePart( m_BackNormalsActor );
        m_NormalsActorAdded = false;
      }
    }

    // Add black background for all images (which may be transparent)
    m_BackgroundMapper->SetInput( surface->GetVtkPolyData() );
    m_ImageAssembly->AddPart( m_BackgroundActor );

    LayerSortedActorList layerSortedActors;


    // Traverse the data tree to find nodes resliced by ImageMapperGL2D
    mitk::NodePredicateDataType::Pointer p = mitk::NodePredicateDataType::New("Image");
    mitk::DataStorage::SetOfObjects::ConstPointer all = m_DataStorage->GetSubset(p);
    for (mitk::DataStorage::SetOfObjects::ConstIterator it = all->Begin(); it != all->End(); ++it)
    {
      DataNode *node = it->Value();
      if (node != NULL)
        this->ProcessNode(node, renderer, surface, layerSortedActors);
    }


    // Add all image actors to the assembly, sorted according to
    // layer property
    LayerSortedActorList::iterator actorIt;
    for ( actorIt = layerSortedActors.begin(); actorIt != layerSortedActors.end(); ++actorIt )
      m_ImageAssembly->AddPart( actorIt->second );

    // Configurate the tube-shaped frame: size according to the surface
    // bounds, color as specified in the plane's properties
    vtkPolyData *surfacePolyData = surface->GetVtkPolyData();
    m_Cleaner->SetInput(surfacePolyData);
    m_EdgeTransformer->SetTransform(this->GetDataNode()->GetVtkTransform(this->GetTimestep()) );

    // Determine maximum extent
    vtkFloatingPointType* surfaceBounds = surfacePolyData->GetBounds();
    vtkFloatingPointType extent = surfaceBounds[1] - surfaceBounds[0];
    vtkFloatingPointType extentY = surfaceBounds[3] - surfaceBounds[2];
    vtkFloatingPointType extentZ = surfaceBounds[5] - surfaceBounds[4];

    if ( extent < extentY ) 
      extent = extentY;
    if ( extent < extentZ ) 
      extent = extentZ;


    // Adjust the radius according to extent

virtual const char* mitk::Geometry2DDataVtkMapper3D::GetClassName ( ) const [virtual]

Reimplemented from mitk::VtkMapper3D.

const Geometry2DData * mitk::Geometry2DDataVtkMapper3D::GetInput ( void ) [virtual]

Get the Geometry2DData to map.

Definition at line 191 of file mitkGeometry2DDataVtkMapper3D.cpp.

References mitk::Mapper::GetDataNode(), and m_ImageAssembly.

{
  if ( (this->GetDataNode() != NULL )

vtkProp * mitk::Geometry2DDataVtkMapper3D::GetVtkProp ( mitk::BaseRenderer * renderer ) [virtual]

Overloaded since the displayed color-frame of the image mustn't be transformed after generation of poly data, but before (vertex coordinates only)

Implements mitk::VtkMapper3D.

Definition at line 169 of file mitkGeometry2DDataVtkMapper3D.cpp.

void mitk::Geometry2DDataVtkMapper3D::ImageMapperDeletedCallback	(	itk::Object *	caller,
		const itk::EventObject &	event
	)		`[protected]`

Definition at line 274 of file mitkGeometry2DDataVtkMapper3D.cpp.

{
  int size;

  for ( --i, size = 1; i > 0; size *= 2 )
  {
    i /= 2;

static Pointer mitk::Geometry2DDataVtkMapper3D::New ( ) [static]

Referenced by mitk::CoreObjectFactory::CreateMapper(), and mitkDataNodeTestClass::TestMapperSetting().

void mitk::Geometry2DDataVtkMapper3D::ProcessNode	(	DataNode *	node,
		BaseRenderer *	renderer,
		Surface *	surface,
		LayerSortedActorList &	layerSortedActors
	)		`[protected]`

Definition at line 542 of file mitkGeometry2DDataVtkMapper3D.cpp.

References mitk::ColorProperty::GetColor(), and m_EdgeActor.

    {
      const Color& color = colorProperty->GetColor();
      m_EdgeActor->GetProperty()->SetColor(color.GetRed(), color.GetGreen(), color.GetBlue());
    }
    else
    {
      m_EdgeActor->GetProperty()->SetColor( 1.0, 1.0, 1.0 );
    }

    m_ImageAssembly->SetUserTransform(this->GetDataNode()->GetVtkTransform(this->GetTimestep()) );
  }

  VtkRepresentationProperty* representationProperty;
  this->GetDataNode()->GetProperty(representationProperty, "material.representation", renderer);
  if ( representationProperty != NULL )
    m_BackgroundActor->GetProperty()->SetRepresentation( representationProperty->GetVtkRepresentation() );
}


void Geometry2DDataVtkMapper3D::ProcessNode( DataNode * node, BaseRenderer* renderer, Surface * surface, LayerSortedActorList &layerSortedActors )
{
  if ( node != NULL )
  {
    ImageMapperGL2D *imageMapper =
      dynamic_cast< ImageMapperGL2D * >( node->GetMapper(1) );

    if ( (node->IsVisible(renderer)) && imageMapper )
    {
      WeakPointerProperty::Pointer rendererProp =
        dynamic_cast< WeakPointerProperty * >(GetDataNode()->GetPropertyList()->GetProperty("renderer"));

      if ( rendererProp.IsNotNull() )
      {
        BaseRenderer::Pointer planeRenderer = dynamic_cast< BaseRenderer * >(rendererProp->GetWeakPointer().GetPointer());
        if ( planeRenderer.IsNotNull() )
        {
          // If it has not been initialized already in a previous pass,
          // generate an actor, a lookup table and a texture object to
          // render the image associated with the ImageMapperGL2D.
          vtkActor *imageActor;
          vtkDataSetMapper *dataSetMapper = NULL;
          vtkLookupTable *lookupTable;
          vtkTexture *texture;
          if ( m_ImageActors.count( imageMapper ) == 0 )
          {
            dataSetMapper = vtkDataSetMapper::New();
            dataSetMapper->ImmediateModeRenderingOn();

            lookupTable = vtkLookupTable::New();
            lookupTable->DeepCopy( m_DefaultLookupTable );
            lookupTable->SetRange( -1024.0, 4095.0 );

            texture = vtkTexture::New();
            texture->InterpolateOn();
            texture->SetLookupTable( lookupTable );
            texture->RepeatOff();

            imageActor = vtkActor::New();
            imageActor->GetProperty()->SetAmbient( 0.5 );
            imageActor->SetMapper( dataSetMapper );
            imageActor->SetTexture( texture );

            // Make imageActor the sole owner of the mapper and texture
            // objects
            lookupTable->UnRegister( NULL );
            dataSetMapper->UnRegister( NULL );
            texture->UnRegister( NULL );

            // Store the actor so that it may be accessed in following
            // passes.
            m_ImageActors[imageMapper].Initialize(imageActor, imageMapper, m_ImageMapperDeletedCommand);
          }
          else
          {
            // Else, retrieve the actor and associated objects from the
            // previous pass.
            imageActor = m_ImageActors[imageMapper].m_Actor;
            dataSetMapper = (vtkDataSetMapper *)imageActor->GetMapper();
            texture = imageActor->GetTexture();

            //BUG (#1551) added dynamic cast for VTK5.2 support
#if ( ( VTK_MAJOR_VERSION >= 5 ) && ( VTK_MINOR_VERSION>=2)  )
            lookupTable = dynamic_cast<vtkLookupTable*>(texture->GetLookupTable());
#else
            lookupTable = texture->GetLookupTable();
#endif
          }

          // Set poly data new each time its object changes (e.g. when
          // switching between planar and curved geometries)
          if ( dataSetMapper != NULL )
          {
            if ( dataSetMapper->GetInput() != surface->GetVtkPolyData() )
            {
              dataSetMapper->SetInput( surface->GetVtkPolyData() );
            }
          }

          imageActor->GetMapper()->GetInput()->Update();
          imageActor->GetMapper()->Update();

          // We have to do this before GenerateAllData() is called
          // since there may be no RendererInfo for renderer yet,
          // thus GenerateAllData won't update the (non-existing)
          // RendererInfo for renderer. By calling GetRendererInfo
          // a RendererInfo will be created for renderer (if it does not
          // exist yet).
          imageMapper->GetRendererInfo( planeRenderer );

          imageMapper->GenerateAllData();

          // ensure the right openGL context, as 3D widgets may render and take their plane texture from 2D image mappers
          renderer->GetRenderWindow()->MakeCurrent();

          // Retrieve and update image to be mapped
          const ImageMapperGL2D::RendererInfo *rit =
            imageMapper->GetRendererInfo( planeRenderer );
          if(rit->m_Image != NULL)
          {
            rit->m_Image->Update();
            texture->SetInput( rit->m_Image );
            // check for level-window-prop and use it if it exists
            ScalarType windowMin = 0.0;
            ScalarType windowMax = 255.0;
            LevelWindow levelWindow;

            bool binary = false;
            node->GetBoolProperty( "binary", binary, renderer );

            // VTK (mis-)interprets unsigned char (binary) images as color images;
            // So, we must manually turn on their mapping through a (gray scale) lookup table;
            if( binary ) 
              texture->MapColorScalarsThroughLookupTableOn();
            else
              texture->MapColorScalarsThroughLookupTableOff();

            if( binary )
            {
              windowMin = 0;
              windowMax = 1;
            }
            else if( node->GetLevelWindow( levelWindow, planeRenderer, "levelWindow" )
              || node->GetLevelWindow( levelWindow, planeRenderer ) )
            {
              windowMin = levelWindow.GetLowerWindowBound();
              windowMax = levelWindow.GetUpperWindowBound();
            }

            vtkLookupTable *lookupTableSource;
            // check for "use color"
            bool useColor;
            if ( !node->GetBoolProperty( "use color", useColor, planeRenderer ) )
              useColor = false;
            if ( binary )
              useColor = true;

            // check for LookupTable
            LookupTableProperty::Pointer lookupTableProp;
            lookupTableProp = dynamic_cast< LookupTableProperty * >(node->GetPropertyList()->GetProperty( "LookupTable" ));

            // If there is a lookup table supplied, use it; otherwise,
            // use the default grayscale table
            if ( lookupTableProp.IsNotNull()  && !useColor )
            {
              lookupTableSource = lookupTableProp->GetLookupTable()->GetVtkLookupTable();
            }
            else
            {
              lookupTableSource = m_DefaultLookupTable;
            }

            LookupTableProperties &lutProperties =
              m_LookupTableProperties[imageMapper];

            // If there has been some change since the last pass which
            // makes it necessary to re-build the lookup table, do it.
            if ( (lutProperties.LookupTableSource != lookupTableSource)
              || (lutProperties.windowMin != windowMin)
              || (lutProperties.windowMax != windowMax) )
            {
              // Note the values for the next pass (lutProperties is a
              // reference to the list entry!)
              if ( lutProperties.LookupTableSource != NULL )
              {
                lutProperties.LookupTableSource->Delete();
              }
              lutProperties.LookupTableSource = lookupTableSource;
              lutProperties.LookupTableSource->Register( NULL );
              lutProperties.windowMin = windowMin;
              lutProperties.windowMax = windowMax;

              lookupTable->DeepCopy( lookupTableSource );
              lookupTable->SetRange( windowMin, windowMax );
            }

            // Apply color property (of the node, not of the plane)
            float rgb[3] = { 1.0, 1.0, 1.0 };
            node->GetColor( rgb, renderer );