Alternative Vtk-based 3D mapper for mitk::PointSet. More...

#include <mitkEnhancedPointSetVtkMapper3D.h>

Inheritance diagram for mitk::EnhancedPointSetVtkMapper3D:

Collaboration diagram for mitk::EnhancedPointSetVtkMapper3D:

Public Types
typedef EnhancedPointSetVtkMapper3D	Self
typedef VtkMapper3D	Superclass
typedef itk::SmartPointer< Self >	Pointer
typedef itk::SmartPointer < const Self >	ConstPointer
Public Member Functions
virtual const char *	GetClassName () const
virtual const mitk::PointSet *	GetInput ()
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.
void	ReleaseGraphicsResources (vtkWindow *renWin)
	Release vtk-based graphics resources. Must be overwritten in subclasses if vtkProps additional to m_Prop3D are used.
Static Public Member Functions
static Pointer	New ()
static void	SetDefaultProperties (mitk::DataNode node, mitk::BaseRenderer renderer=NULL, bool overwrite=false)
	Set default values of properties used by this mapper to node.
Protected Types
typedef mitk::PointSet::PointIdentifier	PointIdentifier
typedef std::map < PointIdentifier, vtkSphereSource * >	SphereSourceMap
typedef std::map < PointIdentifier, vtkCubeSource * >	CubeSourceMap
typedef std::map < PointIdentifier, vtkConeSource * >	ConeSourceMap
typedef std::map < PointIdentifier, vtkCylinderSource * >	CylinderSourceMap
typedef std::pair< vtkActor *, mitk::PointSpecificationType >	ActorAndPointType
typedef std::map < PointIdentifier, ActorAndPointType >	ActorMap
Protected Member Functions
	EnhancedPointSetVtkMapper3D ()
virtual	~EnhancedPointSetVtkMapper3D ()
void	RemoveEntryFromSourceMaps (mitk::PointSet::PointIdentifier pointID)
void	DeleteVtkObject (vtkObject *o)
void	UpdateVtkObjects ()
virtual void	GenerateData ()
	Generate the data needed for rendering (independent of a specific renderer)
virtual void	GenerateData (mitk::BaseRenderer *renderer)
	Generate the data needed for rendering into renderer.
virtual void	ApplyProperties (mitk::BaseRenderer *renderer)
Protected Attributes
SphereSourceMap	m_SphereSources
CubeSourceMap	m_CubeSources
ConeSourceMap	m_ConeSources
CylinderSourceMap	m_CylinderSources
ActorMap	m_PointActors
vtkActor *	m_Contour
vtkTubeFilter *	m_ContourSource
vtkAssembly *	m_PropAssembly

Detailed Description

Alternative Vtk-based 3D mapper for mitk::PointSet.

This class renders mitk::PointSet objects in 3D views. It resembles the standard mitk::PointSetVtkMapper3D, but is designed to enable single points to be rendered with individual appearances.

Instead of assembling one vtkPolyData object containing all points, a list of VTK source objects (spheres, cubes, cones, ...) is maintained. Therefore, the application can change the appearance and/or type of a specific point at runtime, without having to rebuild the

You should use this class instead of the standard mapper if you

change the PointSet very often (by adding or removing points)
need different representations for points (+++)
want to change the point representation frequently (+++)

Note: the class is still in experimental stage, and the points above marked with (+++) are not yet working correctly. Also, drawing lines between points (contour mode) is not yet supported. The class will be extended so that point representations are stored in a lookup table, which is indexed by point data from the rendered PointSet.

This mapper requires the PointData container to be the same size as the point container.

See also:: PointSetVtkMapper3D

Definition at line 70 of file mitkEnhancedPointSetVtkMapper3D.h.

Member Typedef Documentation

typedef std::pair<vtkActor*, mitk::PointSpecificationType> mitk::EnhancedPointSetVtkMapper3D::ActorAndPointType [protected]

Definition at line 109 of file mitkEnhancedPointSetVtkMapper3D.h.

typedef std::map<PointIdentifier, ActorAndPointType> mitk::EnhancedPointSetVtkMapper3D::ActorMap [protected]

Definition at line 110 of file mitkEnhancedPointSetVtkMapper3D.h.

typedef std::map<PointIdentifier, vtkConeSource*> mitk::EnhancedPointSetVtkMapper3D::ConeSourceMap [protected]

Definition at line 106 of file mitkEnhancedPointSetVtkMapper3D.h.

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

Reimplemented from mitk::VtkMapper3D.

Definition at line 73 of file mitkEnhancedPointSetVtkMapper3D.h.

typedef std::map<PointIdentifier, vtkCubeSource*> mitk::EnhancedPointSetVtkMapper3D::CubeSourceMap [protected]

Definition at line 105 of file mitkEnhancedPointSetVtkMapper3D.h.

typedef std::map<PointIdentifier, vtkCylinderSource*> mitk::EnhancedPointSetVtkMapper3D::CylinderSourceMap [protected]

Definition at line 107 of file mitkEnhancedPointSetVtkMapper3D.h.

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

Reimplemented from mitk::VtkMapper3D.

Definition at line 73 of file mitkEnhancedPointSetVtkMapper3D.h.

typedef mitk::PointSet::PointIdentifier mitk::EnhancedPointSetVtkMapper3D::PointIdentifier [protected]

Definition at line 103 of file mitkEnhancedPointSetVtkMapper3D.h.

typedef EnhancedPointSetVtkMapper3D mitk::EnhancedPointSetVtkMapper3D::Self

Reimplemented from mitk::VtkMapper3D.

Definition at line 73 of file mitkEnhancedPointSetVtkMapper3D.h.

typedef std::map<PointIdentifier, vtkSphereSource*> mitk::EnhancedPointSetVtkMapper3D::SphereSourceMap [protected]

Definition at line 104 of file mitkEnhancedPointSetVtkMapper3D.h.

typedef VtkMapper3D mitk::EnhancedPointSetVtkMapper3D::Superclass

Reimplemented from mitk::VtkMapper3D.

Definition at line 73 of file mitkEnhancedPointSetVtkMapper3D.h.

Constructor & Destructor Documentation

mitk::EnhancedPointSetVtkMapper3D::EnhancedPointSetVtkMapper3D ( ) [protected]

Definition at line 55 of file mitkEnhancedPointSetVtkMapper3D.cpp.

{
  m_Contour = vtkActor::New();
  m_ContourSource = vtkTubeFilter::New();
  m_PropAssembly = vtkAssembly::New();
}

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

Definition at line 67 of file mitkEnhancedPointSetVtkMapper3D.cpp.

{
  m_Contour->Delete();
  m_ContourSource->Delete();
  m_PropAssembly->Delete();
  
  // TODO: do cleanup correctly

  // Clean up all remaining actors and poly-data sources
  //std::for_each(m_PointActors.begin(), m_PointActors.end(), &mitk::EnhancedPointSetVtkMapper3D::DeleteVtkObject);

//  std::for_each(m_SphereSources.begin(), m_SphereSources.end(), &mitk::EnhancedPointSetVtgkMapper3D::DeleteVtkObject);
//  std::for_each(m_CubeSources.begin(), m_CubeSources.end(), &mitk::EnhancedPointSetVtkMapper3D::DeleteVtkObject);
//  std::for_each(m_ConeSources.begin(), m_ConeSources.end(), &mitk::EnhancedPointSetVtkMapper3D::DeleteVtkObject);
//  std::for_each(m_CylinderSources.begin(), m_CylinderSources.end(), &mitk::EnhancedPointSetVtkMapper3D::DeleteVtkObject);
//
}

Member Function Documentation

void mitk::EnhancedPointSetVtkMapper3D::ApplyProperties ( mitk::BaseRenderer * renderer ) [protected, virtual]

Definition at line 198 of file mitkEnhancedPointSetVtkMapper3D.cpp.

References mitk::DataNode::GetColor(), mitk::DataNode::GetFloatProperty(), mitk::LookupTableProperty::GetLookupTable(), mitk::DataNode::GetOpacity(), mitk::PointSet::GetPointSet(), mitk::DataNode::GetProperty(), mitk::GenericLookupTable< T >::GetTableValue(), mitk::GenericProperty< T >::GetValue(), mitk::LookupTable::GetVtkLookupTable(), mitk::DataNode::IsVisible(), mitk::PointSet::PointDataType::pointSpec, and mitk::PointSet::PointDataType::selected.

{
  /* iterate over all points in pointset and apply properties to corresponding vtk objects */
  // get and update the PointSet
  const mitk::PointSet* pointset = this->GetInput();
  int timestep = this->GetTimestep();
  mitk::PointSet::DataType* itkPointSet = pointset->GetPointSet( timestep );
  mitk::PointSet::PointsContainer* points = itkPointSet->GetPoints();
  mitk::PointSet::PointDataContainer* pointData = itkPointSet->GetPointData();
  assert(points->Size() == pointData->Size());
  mitk::PointSet::PointsIterator pIt;
  mitk::PointSet::PointDataIterator pdIt;
  mitk::DataNode* n = this->GetDataNode();
  assert(n != NULL);

  for (pIt = points->Begin(), pdIt = pointData->Begin(); pIt != itkPointSet->GetPoints()->End(); ++pIt, ++pdIt)  // for each point in the pointset
  {
    PointIdentifier pointID = pIt->Index();
    assert (pointID == pdIt->Index());

    mitk::PointSet::PointType point = pIt->Value();
    mitk::PointSet::PointDataType data = pdIt->Value();

    ActorMap::iterator aIt = m_PointActors.find(pointID); // Does an actor exist for the point?
    assert(aIt != m_PointActors.end()); // UpdateVtkObjects() must ensure that actor exists
    
    vtkActor* a = aIt->second.first;
    assert(a != NULL);

    SetVtkMapperImmediateModeRendering(a->GetMapper());

    /* update properties */
    // visibility
    bool pointVisibility = true;
    bool visValueFound = false;
    mitk::BaseProperty* visProp = n->GetProperty("visibility", renderer);
    mitk::BoolLookupTableProperty* visLTProp = dynamic_cast<mitk::BoolLookupTableProperty*>(visProp);
    if (visLTProp != NULL)
    {
      mitk::BoolLookupTable visLookupTable = visLTProp->GetValue();
      //if (visLookupTable != NULL)
      //{
        try
        {
          pointVisibility = visLookupTable.GetTableValue(pointID);
          visValueFound = true;
        }
        catch (...)
        {
        }
      //}
    }
    if (visValueFound == false)
    {
      pointVisibility = n->IsVisible(renderer, "show points");  // use BoolProperty instead
    }
    a->SetVisibility(pointVisibility);

    // opacity
    float opacity = 1.0;
    bool opValueFound = false;
    mitk::BaseProperty* opProp = n->GetProperty("opacity", renderer);
    mitk::FloatLookupTableProperty* opLTProp = dynamic_cast<mitk::FloatLookupTableProperty*>(opProp);
    if (opLTProp != NULL)
    {
      mitk::FloatLookupTable opLookupTable = opLTProp->GetValue();
      //if (opLookupTable != NULL)
      //{
        try
        {
          opacity = opLookupTable.GetTableValue(pointID);
          opValueFound = true;
        }
        catch (...)
        {
        }
      //}
    }
    if (opValueFound == false)
    {
      n->GetOpacity(opacity, renderer);
    }
    a->GetProperty()->SetOpacity(opacity);

    // pointsize & point position
    float pointSize = 1.0;
    n->GetFloatProperty( "pointsize", pointSize, renderer);
    switch (data.pointSpec)
    {                                               //TODO: look up representation in a representationlookuptable
    case PTSTART:        //cube
      m_CubeSources[pointID]->SetXLength(pointSize);
      m_CubeSources[pointID]->SetYLength(pointSize);
      m_CubeSources[pointID]->SetZLength(pointSize);
      //m_CubeSources[pointID]->SetCenter(pos[0], pos[1], pos[2]);
      break;
    case PTCORNER:          //cone
      m_ConeSources[pointID]->SetRadius(pointSize/2);
      m_ConeSources[pointID]->SetHeight(pointSize);
      m_ConeSources[pointID]->SetResolution(2); // two crossed triangles. Maybe introduce an extra property for 
      //m_ConeSources[pointID]->SetCenter(pos[0], pos[1], pos[2]);
      break;
    case PTEDGE:          // cylinder
      m_CylinderSources[pointID]->SetRadius(pointSize/2);
      m_CylinderSources[pointID]->SetHeight(pointSize);
      m_CylinderSources[pointID]->CappingOn();
      m_CylinderSources[pointID]->SetResolution(6);
      //m_CylinderSources[pointID]->SetCenter(pos[0], pos[1], pos[2]);
      break;
    case PTUNDEFINED:     // sphere
    case PTEND:
    default:
      m_SphereSources[pointID]->SetRadius(pointSize/2);
      m_SphereSources[pointID]->SetThetaResolution(10);
      m_SphereSources[pointID]->SetPhiResolution(10);
      //m_SphereSources[pointID]->SetCenter(pos[0], pos[1], pos[2]);
      break;
    }

    // set position
    mitk::Point3D pos = pIt->Value();
    aIt->second.first->SetPosition(pos[0], pos[1], pos[2]);

    // selectedcolor & color
    float color[3];
    if (data.selected)
    {
      if(!n->GetColor(color, renderer, "selectedcolor"))
        n->GetColor(color, renderer);
    }
    else
    {
      mitk::BaseProperty* a = n->GetProperty("colorLookupTable", renderer);
      mitk::LookupTableProperty* b = dynamic_cast<mitk::LookupTableProperty*>(a);
      if (b != NULL)
      {
         mitk::LookupTable::Pointer c = b->GetLookupTable();    
         vtkLookupTable *d = c->GetVtkLookupTable();
         double *e=d->GetTableValue(pointID);
         color[0]=e[0];         
         color[1]=e[1];         
         color[2]=e[2];         
      }
      else
      {
        if(!n->GetColor(color, renderer, "unselectedcolor"))
          n->GetColor(color, renderer);
      }
    }
      
     
        // TODO: What about "color" property? 2D Mapper only uses unselected and selected color properties
    a->GetProperty()->SetColor(color[0], color[1], color[2]);

    // TODO: label property
  }
  //TODO test different pointSpec
  // TODO "line width" "show contour" "contourcolor" "contoursize" "close contour" "show label", "label"
  // TODO "show points" vs "visibility"  - is visibility evaluated at all? in a superclass maybe? 
  // TODO create lookup tables for all properties that should be evaluated per point. also create editor widgets for these lookup tables!
  // TODO check if property changes and pointset changes are reflected in the render window immediately.
  // TODO check behavior with large PointSets
  // TODO check for memory leaks on adding/deleting points
}

void mitk::EnhancedPointSetVtkMapper3D::DeleteVtkObject ( vtkObject * o ) [protected]

Definition at line 402 of file mitkEnhancedPointSetVtkMapper3D.cpp.

{
  if (o != NULL)
    o->Delete();
}

void mitk::EnhancedPointSetVtkMapper3D::GenerateData ( ) [protected, virtual]

Generate the data needed for rendering (independent of a specific renderer)

Reimplemented from mitk::Mapper.

Definition at line 192 of file mitkEnhancedPointSetVtkMapper3D.cpp.

{
  this->UpdateVtkObjects();
}

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

Generate the data needed for rendering into renderer.

Reimplemented from mitk::Mapper.

Definition at line 364 of file mitkEnhancedPointSetVtkMapper3D.cpp.

{
  ApplyProperties(renderer);
}

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

Reimplemented from mitk::VtkMapper3D.

const mitk::PointSet * mitk::EnhancedPointSetVtkMapper3D::GetInput ( void ) [virtual]

Definition at line 50 of file mitkEnhancedPointSetVtkMapper3D.cpp.

References mitk::Mapper::GetData().

{
  return static_cast<const mitk::PointSet * > ( GetData() );
}

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

Implements mitk::VtkMapper3D.

Definition at line 62 of file mitkEnhancedPointSetVtkMapper3D.cpp.

{
  return m_PropAssembly;
}

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

void mitk::EnhancedPointSetVtkMapper3D::ReleaseGraphicsResources ( vtkWindow * renWin ) [virtual]

Release vtk-based graphics resources. Must be overwritten in subclasses if vtkProps additional to m_Prop3D are used.

Reimplemented from mitk::VtkMapper3D.

Definition at line 85 of file mitkEnhancedPointSetVtkMapper3D.cpp.

{
  // TODO: Do we have to call this for all actors??
  //m_Actor->ReleaseGraphicsResources(renWin);
}

void mitk::EnhancedPointSetVtkMapper3D::RemoveEntryFromSourceMaps ( mitk::PointSet::PointIdentifier pointID ) [protected]

Definition at line 409 of file mitkEnhancedPointSetVtkMapper3D.cpp.

{
  ActorMap::iterator aIt = m_PointActors.find(pointID);
  if (aIt == m_PointActors.end())
    return;

  switch (aIt->second.second)  // erase in old map
  {      //TODO: look up representation in a representationlookuptable
  case PTSTART:        //cube
    m_CubeSources[pointID]->Delete();
    m_CubeSources.erase(pointID);
    break;

  case PTCORNER:          //cone
    m_ConeSources[pointID]->Delete();
    m_ConeSources.erase(pointID);
    break;

  case PTEDGE:          // cylinder
    m_CylinderSources[pointID]->Delete();
    m_CylinderSources.erase(pointID);
    break;

  case PTUNDEFINED:     // sphere
  case PTEND:
  default:
    m_SphereSources[pointID]->Delete();
    m_SphereSources.erase(pointID);          
    break;
  }        
}

void mitk::EnhancedPointSetVtkMapper3D::SetDefaultProperties	(	mitk::DataNode *	node,
		mitk::BaseRenderer *	renderer = `NULL`,
		bool	overwrite = `false`
	)		`[static]`

Set default values of properties used by this mapper to node.

Parameters:

node	The node for which the properties are set
overwrite	overwrite existing properties (default: false)
renderer	defines which property list of node is used (default: NULL, i.e. default property list)

Reimplemented from mitk::Mapper.

Definition at line 383 of file mitkEnhancedPointSetVtkMapper3D.cpp.

References mitk::DataNode::AddProperty(), mitk::StringProperty::New(), mitk::BoolProperty::New(), mitk::ColorProperty::New(), mitk::FloatProperty::New(), and mitk::IntProperty::New().

{
  node->AddProperty( "line width", mitk::IntProperty::New(2), renderer, overwrite );
  node->AddProperty( "pointsize", mitk::FloatProperty::New(1.0), renderer, overwrite);
  node->AddProperty( "selectedcolor", mitk::ColorProperty::New(1.0f, 1.0f, 0.0f), renderer, overwrite);  //yellow for selected
  node->AddProperty( "unselectedcolor", mitk::ColorProperty::New(0.5f, 1.0f, 0.5f), renderer, overwrite);  // middle green for unselected
  node->AddProperty( "color", mitk::ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite);  // red as standard
  node->AddProperty( "show contour", mitk::BoolProperty::New(false), renderer, overwrite );
  node->AddProperty( "contourcolor", mitk::ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite);
  node->AddProperty( "contoursize", mitk::FloatProperty::New(0.5), renderer, overwrite );
  node->AddProperty( "close contour", mitk::BoolProperty::New(false), renderer, overwrite );
  node->AddProperty( "show points", mitk::BoolProperty::New(true), renderer, overwrite );
  node->AddProperty( "show label", mitk::BoolProperty::New(false), renderer, overwrite );
  node->AddProperty( "label", mitk::StringProperty::New("P"), renderer, overwrite );
  node->AddProperty( "opacity", mitk::FloatProperty::New(1.0), renderer, overwrite );
  Superclass::SetDefaultProperties(node, renderer, overwrite);
}

void mitk::EnhancedPointSetVtkMapper3D::UpdateVtkObjects ( ) [protected]

Definition at line 91 of file mitkEnhancedPointSetVtkMapper3D.cpp.

References mitk::PointSet::GetPointSet(), and mitk::PointSet::PointDataType::pointSpec.

{
  // get and update the PointSet
  const mitk::PointSet* pointset = this->GetInput();
  //pointset->Update();
  int timestep = this->GetTimestep();
 
  mitk::PointSet::DataType* itkPointSet = pointset->GetPointSet( timestep );
  mitk::PointSet::PointsContainer* points = itkPointSet->GetPoints();
  mitk::PointSet::PointDataContainer* pointData = itkPointSet->GetPointData();
  
  assert(points->Size() == pointData->Size());

  mitk::PointSet::PointsIterator pIt;
  mitk::PointSet::PointDataIterator pdIt;
  
  /* search removed points and delete the corresponding source/actor/mapper objects */
  for (ActorMap::iterator it = m_PointActors.begin(); it != m_PointActors.end(); )
  {
    PointIdentifier id = it->first;
    if (!points->IndexExists(id))
    {
      this->RemoveEntryFromSourceMaps(id);
      m_PropAssembly->GetParts()->RemoveItem(it->second.first); // remove from prop assembly
      if (it->second.first != NULL)
        it->second.first->Delete(); // Delete actor, which deletes mapper too (reference count)
      ActorMap::iterator er = it; // save iterator for deleting
      ++it;  // advance iterator to next object
      m_PointActors.erase(er); // erase element from map. This invalidates er, therefore we had to advance it before deletion.
    }
    else
      ++it;
  }
  
  /* iterate over each point in the pointset and create corresponding vtk objects */
  for (pIt = points->Begin(), pdIt = pointData->Begin(); pIt != itkPointSet->GetPoints()->End(); ++pIt, ++pdIt)
  {
    PointIdentifier pointID = pIt->Index();
    assert (pointID == pdIt->Index());

    mitk::PointSet::PointType point = pIt->Value();
    mitk::PointSet::PointDataType data = pdIt->Value();
    
    ActorMap::iterator aIt = m_PointActors.find(pointID); // Does an actor exist for the point?

    /* Create/Update sources for the point */
    vtkActor* a = NULL;
    bool newPoint = (aIt == m_PointActors.end()); // current point is new
    bool specChanged = (!newPoint && data.pointSpec != aIt->second.second); // point spec of current point has changed

    if (newPoint)  // point did not exist before, we have to create vtk objects for it
    { // create actor and mapper for the new point
      a = vtkActor::New();
      vtkPolyDataMapper* m = vtkPolyDataMapper::New();
      a->SetMapper(m);
      m->UnRegister( NULL );
      aIt = m_PointActors.insert(std::make_pair(pointID, std::make_pair(a, data.pointSpec))).first;  // insert element and update actormap iterator to point to new element
      m_PropAssembly->AddPart(a);
    }
    else
    {
      a = aIt->second.first;
      if (specChanged)  // point exists, but point spec has changed
      {     
        this->RemoveEntryFromSourceMaps( pointID );
      }
    }
    if ( newPoint || specChanged ) // new point OR existing point but point spec changed
    {
      vtkPolyDataAlgorithm* source = NULL;  // works only in VTK 5+
      switch (data.pointSpec)  // add to new map
      {                                               //TODO: look up representation in a representationlookuptable
      case PTSTART:        //cube
        m_CubeSources[pointID] = vtkCubeSource::New();
        source = m_CubeSources[pointID];
        break;
      case PTCORNER:          //cone
        m_ConeSources[pointID] = vtkConeSource::New();
        source = m_ConeSources[pointID];
        break;
      case PTEDGE:          // cylinder
        m_CylinderSources[pointID] = vtkCylinderSource::New();
        source = m_CylinderSources[pointID];
        break;
      case PTUNDEFINED:     // sphere
      case PTEND:
      default:
        m_SphereSources[pointID] = vtkSphereSource::New();
        source = m_SphereSources[pointID];
        break;
      }
      vtkPolyDataMapper* m = dynamic_cast<vtkPolyDataMapper*>(a->GetMapper());
      assert(m != NULL);
      m->SetInput(source->GetOutput());
      aIt->second.second = data.pointSpec; // update point spec in actormap
    }
  } // for each point  
}

void mitk::EnhancedPointSetVtkMapper3D::UpdateVtkTransform ( mitk::BaseRenderer * renderer ) [virtual]

Set the vtkTransform of the m_Prop3D for the current time step of renderer.

Called by mitk::VtkPropRenderer::Update before rendering

Reimplemented from mitk::VtkMapper3D.

Definition at line 370 of file mitkEnhancedPointSetVtkMapper3D.cpp.

{
  // TODO: apply new transform if time step changed

  //vtkLinearTransform * vtktransform = 
  //  this->GetDataNode()->GetVtkTransform(this->GetTimestep());

  //m_SelectedActor->SetUserTransform(vtktransform);
  //m_UnselectedActor->SetUserTransform(vtktransform);
  //m_ContourActor->SetUserTransform(vtktransform);
}