Vtk-based mapper for PointSet. More...

#include <mitkPointSetVtkMapper3D.h>

Inheritance diagram for mitk::PointSetVtkMapper3D:

Collaboration diagram for mitk::PointSetVtkMapper3D:

Public Types
typedef PointSetVtkMapper3D	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 Member Functions
	PointSetVtkMapper3D ()
virtual	~PointSetVtkMapper3D ()
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	ResetMapper (BaseRenderer *renderer)
virtual void	ApplyProperties (mitk::BaseRenderer *renderer)
virtual void	CreateContour (mitk::BaseRenderer *renderer)
virtual void	CreateVTKRenderObjects ()
Protected Attributes
vtkAppendPolyData *	m_vtkSelectedPointList
vtkAppendPolyData *	m_vtkUnselectedPointList
vtkPolyDataMapper *	m_VtkSelectedPolyDataMapper
vtkPolyDataMapper *	m_VtkUnselectedPolyDataMapper
vtkActor *	m_SelectedActor
vtkActor *	m_UnselectedActor
vtkActor *	m_ContourActor
vtkPropAssembly *	m_PointsAssembly
vtkAppendPolyData *	m_vtkTextList
unsigned int	m_NumberOfSelectedAdded
unsigned int	m_NumberOfUnselectedAdded
ScalarType	m_PointSize
ScalarType	m_ContourRadius

Detailed Description

Vtk-based mapper for PointSet.

Due to the need of different colors for selected and unselected points and the facts, that we also have a contour and labels for the points, the vtk structure is build up the following way:

We have two AppendPolyData, one selected, and one unselected and one for a contour between the points. Each one is connected to an own PolyDaraMapper and an Actor. The different color for the unselected and selected state and for the contour is read from properties.

"unselectedcolor", "selectedcolor" and "contourcolor" are the strings, that are looked for. Pointlabels are added besides the selected or the deselected points.

Then the three Actors are combined inside a vtkPropAssembly and this object is returned in GetProp() and so hooked up into the rendering pipeline.

Properties that can be set for point sets and influence the PointSetVTKMapper3D are:

"color": (ColorProperty*) Color of the point set
"Opacity": (FloatProperty) Opacity of the point set
"show contour": (BoolProperty) If the contour of the points are visible
"contourSizeProp":(FloatProperty) Contour size of the points

The default properties are:

"line width": (IntProperty::New(2), renderer, overwrite )
"pointsize": (FloatProperty::New(1.0), renderer, overwrite)
"selectedcolor": (ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite) //red
"color": (ColorProperty::New(1.0f, 1.0f, 0.0f), renderer, overwrite) //yellow
"show contour": (BoolProperty::New(false), renderer, overwrite )
"contourcolor": (ColorProperty::New(1.0f, 0.0f, 0.0f), renderer, overwrite)
"contoursize": (FloatProperty::New(0.5), renderer, overwrite )
"close contour": (BoolProperty::New(false), renderer, overwrite )
"show points": (BoolProperty::New(true), renderer, overwrite )
"updateDataOnRender": (BoolProperty::New(true), renderer, overwrite )

Other properties looked for are:

"show contour": if set to on, lines between the points are shown
"close contour": if set to on, the open strip is closed (first point connected with last point)
"pointsize": size of the points mapped
"label": text of the Points to show besides points
"contoursize": size of the contour drawn between the points (if not set, the pointsize is taken)

Definition at line 93 of file mitkPointSetVtkMapper3D.h.

Member Typedef Documentation

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

Reimplemented from mitk::VtkMapper3D.

Reimplemented in mitk::LineVtkMapper3D, and mitk::SplineVtkMapper3D.

Definition at line 96 of file mitkPointSetVtkMapper3D.h.

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

Reimplemented from mitk::VtkMapper3D.

Reimplemented in mitk::LineVtkMapper3D, and mitk::SplineVtkMapper3D.

Definition at line 96 of file mitkPointSetVtkMapper3D.h.

typedef PointSetVtkMapper3D mitk::PointSetVtkMapper3D::Self

Reimplemented from mitk::VtkMapper3D.

Reimplemented in mitk::LineVtkMapper3D, and mitk::SplineVtkMapper3D.

Definition at line 96 of file mitkPointSetVtkMapper3D.h.

typedef VtkMapper3D mitk::PointSetVtkMapper3D::Superclass

Reimplemented from mitk::VtkMapper3D.

Reimplemented in mitk::LineVtkMapper3D, and mitk::SplineVtkMapper3D.

Definition at line 96 of file mitkPointSetVtkMapper3D.h.

Constructor & Destructor Documentation

mitk::PointSetVtkMapper3D::PointSetVtkMapper3D ( ) [protected]

Definition at line 57 of file mitkPointSetVtkMapper3D.cpp.

References m_ContourActor, m_PointsAssembly, m_SelectedActor, m_UnselectedActor, and New().

: m_vtkSelectedPointList(NULL),
 m_vtkUnselectedPointList(NULL), 
 //m_vtkContourPolyData(NULL),
 m_VtkSelectedPolyDataMapper(NULL), 
 m_VtkUnselectedPolyDataMapper(NULL),
 //m_vtkContourPolyDataMapper(NULL),
 m_vtkTextList(NULL), 
 //m_Contour(NULL), 
 //m_TubeFilter(NULL),
 m_NumberOfSelectedAdded(0), 
 m_NumberOfUnselectedAdded(0),
 m_PointSize(1.0),
 m_ContourRadius(0.5)
{
  //propassembly
  m_PointsAssembly = vtkPropAssembly::New();

  //creating actors to be able to set transform
  m_SelectedActor = vtkActor::New();
  m_UnselectedActor = vtkActor::New();
  m_ContourActor = vtkActor::New();
}

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

Definition at line 81 of file mitkPointSetVtkMapper3D.cpp.

{
  m_PointsAssembly->Delete();

  m_SelectedActor->Delete();
  m_UnselectedActor->Delete();
  m_ContourActor->Delete();
}

Member Function Documentation

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

!define a new ColorProp to be able to pass alpha value

Definition at line 471 of file mitkPointSetVtkMapper3D.cpp.

References mitk::ColorProperty::GetColor(), mitk::GenericProperty< T >::GetValue(), and selectedColor.

{
  //check for color props and use it for rendering of selected/unselected points and contour 
  //due to different params in VTK (double/float) we have to convert!

  //vars to convert to
  vtkFloatingPointType unselectedColor[4]={1.0f,1.0f,0.0f,1.0f};//yellow
  vtkFloatingPointType selectedColor[4]={1.0f,0.0f,0.0f,1.0f};//red
  vtkFloatingPointType contourColor[4]={1.0f,0.0f,0.0f,1.0f};//red

  //different types for color!!!
  mitk::Color tmpColor;
  double opacity = 1.0;

  //check if there is an unselected property
  if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("unselectedcolor")) != NULL)
  {
    tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("unselectedcolor"))->GetValue();
    unselectedColor[0] = tmpColor[0];
    unselectedColor[1] = tmpColor[1];
    unselectedColor[2] = tmpColor[2];
    unselectedColor[3] = 1.0f; 
  }
  else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("unselectedcolor")) != NULL)
  {
    tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("unselectedcolor"))->GetValue();
    unselectedColor[0] = tmpColor[0];
    unselectedColor[1] = tmpColor[1];
    unselectedColor[2] = tmpColor[2];
    unselectedColor[3] = 1.0f; 
  }
  else
  {
    //check if the node has a color
    float unselectedColorTMP[4]={1.0f,1.0f,0.0f,1.0f};//yellow
    m_DataNode->GetColor(unselectedColorTMP, NULL);
    unselectedColor[0] = unselectedColorTMP[0];
    unselectedColor[1] = unselectedColorTMP[1];
    unselectedColor[2] = unselectedColorTMP[2];
    //unselectedColor[3] stays 1.0f
  }

  //get selected property
  if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor")) != NULL)
  {
    tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("selectedcolor"))->GetValue();
    selectedColor[0] = tmpColor[0];
    selectedColor[1] = tmpColor[1];
    selectedColor[2] = tmpColor[2];
    selectedColor[3] = 1.0f;
  }
  else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor")) != NULL)
  {
    tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("selectedcolor"))->GetValue();
    selectedColor[0] = tmpColor[0];
    selectedColor[1] = tmpColor[1];
    selectedColor[2] = tmpColor[2];
    selectedColor[3] = 1.0f;
  }

  //get contour property
  if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor")) != NULL)
  {
    tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("contourcolor"))->GetValue();
    contourColor[0] = tmpColor[0];
    contourColor[1] = tmpColor[1];
    contourColor[2] = tmpColor[2];
    contourColor[3] = 1.0f;
  }
  else if (dynamic_cast<mitk::ColorProperty*>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor")) != NULL)
  {
    tmpColor = dynamic_cast<mitk::ColorProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("contourcolor"))->GetValue();
    contourColor[0] = tmpColor[0];
    contourColor[1] = tmpColor[1];
    contourColor[2] = tmpColor[2];
    contourColor[3] = 1.0f;
  }

  if(dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("opacity")) != NULL)
  {
    mitk::FloatProperty::Pointer pointOpacity =dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(renderer)->GetProperty("opacity"));
    opacity = pointOpacity->GetValue();
  }
  else if(dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("opacity")) != NULL)
  {
    mitk::FloatProperty::Pointer pointOpacity =dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetPropertyList(NULL)->GetProperty("opacity"));
    opacity = pointOpacity->GetValue();
  }
  //finished color / opacity fishing!

  //check if a contour shall be drawn
  bool makeContour = false;
  this->GetDataNode()->GetBoolProperty("show contour", makeContour, renderer);
  int visibleBefore = m_ContourActor->GetVisibility();
  if(makeContour && (m_ContourActor != NULL) )
  {
    if ( visibleBefore == 0)//was not visible before, so create it.
      this->CreateContour(renderer);
    m_ContourActor->GetProperty()->SetColor(contourColor);
    m_ContourActor->GetProperty()->SetOpacity(opacity);
  }

  m_SelectedActor->GetProperty()->SetColor(selectedColor);
  m_SelectedActor->GetProperty()->SetOpacity(opacity);

  m_UnselectedActor->GetProperty()->SetColor(unselectedColor);
  m_UnselectedActor->GetProperty()->SetOpacity(opacity);

}

void mitk::PointSetVtkMapper3D::CreateContour ( mitk::BaseRenderer * renderer ) [protected, virtual]

Definition at line 581 of file mitkPointSetVtkMapper3D.cpp.

References mitk::GenericProperty< T >::GetValue().

{
  vtkAppendPolyData* vtkContourPolyData = vtkAppendPolyData::New();
  vtkPolyDataMapper* vtkContourPolyDataMapper = vtkPolyDataMapper::New(); 

  vtkPoints *points = vtkPoints::New();
  vtkCellArray *polys = vtkCellArray::New();

  mitk::PointSet::PointsContainer::Iterator pointsIter;
  mitk::PointSet::PointDataContainer::Iterator pointDataIter;
  int j;

  // get and update the PointSet
  mitk::PointSet::Pointer input  = const_cast<mitk::PointSet*>(this->GetInput());
  //input->Update();

  int timestep = this->GetTimestep();
  mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timestep );
  if ( itkPointSet.GetPointer() == NULL) 
  {
    return;
  }

  for (j=0, pointsIter=itkPointSet->GetPoints()->Begin(); pointsIter!=itkPointSet->GetPoints()->End() ; pointsIter++,j++)
  {
    vtkIdType cell[2] = {j-1,j};
    itk::Point<float> point1 = pointsIter->Value();
    points->InsertPoint(j,point1[0],point1[1],point1[2]);
    if (j>0)
      polys->InsertNextCell(2,cell);
  }

  bool close;
  if (dynamic_cast<mitk::BoolProperty *>(this->GetDataNode()->GetPropertyList()->GetProperty("close contour"), renderer) == NULL)
    close = false;
  else
    close = dynamic_cast<mitk::BoolProperty *>(this->GetDataNode()->GetPropertyList()->GetProperty("close contour"), renderer)->GetValue();
  if (close) 
  {
    vtkIdType cell[2] = {j-1,0};
    polys->InsertNextCell(2,cell);
  }

  vtkPolyData* contour = vtkPolyData::New();
  contour->SetPoints(points);
  points->Delete();
  contour->SetLines(polys);
  polys->Delete();
  contour->Update();

  vtkTubeFilter* tubeFilter = vtkTubeFilter::New();
  tubeFilter->SetNumberOfSides( 12 );
  tubeFilter->SetInput(contour);
  contour->Delete();

  //check for property contoursize. 
  m_ContourRadius = 0.5;
  mitk::FloatProperty::Pointer contourSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("contoursize") );

  if (contourSizeProp.IsNotNull())
    m_ContourRadius = contourSizeProp->GetValue();

  tubeFilter->SetRadius( m_ContourRadius );
  tubeFilter->Update();

  //add to pipeline
  vtkContourPolyData->AddInput(tubeFilter->GetOutput());
  tubeFilter->Delete();
  vtkContourPolyDataMapper->SetInput(vtkContourPolyData->GetOutput());
  vtkContourPolyData->Delete();

  //create a new instance of the actor
  m_ContourActor->Delete();
  m_ContourActor = vtkActor::New();

  m_ContourActor->SetMapper(vtkContourPolyDataMapper);
  vtkContourPolyDataMapper->Delete();

  m_PointsAssembly->AddPart(m_ContourActor);
}

void mitk::PointSetVtkMapper3D::CreateVTKRenderObjects ( ) [protected, virtual]

Definition at line 99 of file mitkPointSetVtkMapper3D.cpp.

References mitk::GenericProperty< T >::GetValue().

{
  m_vtkSelectedPointList = vtkAppendPolyData::New();
  m_vtkUnselectedPointList = vtkAppendPolyData::New();

  m_PointsAssembly->VisibilityOn();

  if(m_PointsAssembly->GetParts()->IsItemPresent(m_SelectedActor))
    m_PointsAssembly->RemovePart(m_SelectedActor);
  if(m_PointsAssembly->GetParts()->IsItemPresent(m_UnselectedActor))
    m_PointsAssembly->RemovePart(m_UnselectedActor);
  if(m_PointsAssembly->GetParts()->IsItemPresent(m_ContourActor))
    m_PointsAssembly->RemovePart(m_ContourActor);

  // exceptional displaying for PositionTracker -> MouseOrientationTool
  int mapperID;
  bool isInputDevice=false;   
  if( this->GetDataNode()->GetBoolProperty("inputdevice",isInputDevice) && isInputDevice )
  {
    if( this->GetDataNode()->GetIntProperty("BaseRendererMapperID",mapperID) && mapperID == 2)
      return; //The event for the PositionTracker came from the 3d widget and  not needs to be displayed
  }

  // get and update the PointSet
  mitk::PointSet::Pointer input  = const_cast<mitk::PointSet*>(this->GetInput());
  
  /* only update the input data, if the property tells us to */
  bool update = true;
  this->GetDataNode()->GetBoolProperty("updateDataOnRender", update);
  if (update == true)
    input->Update();

  int timestep = this->GetTimestep();

  mitk::PointSet::DataType::Pointer itkPointSet = input->GetPointSet( timestep );

  if ( itkPointSet.GetPointer() == NULL) 
  {
    m_PointsAssembly->VisibilityOff();
    return;
  }

  mitk::PointSet::PointsContainer::Iterator pointsIter;
  mitk::PointSet::PointDataContainer::Iterator pointDataIter;
  int j;

  m_NumberOfSelectedAdded = 0;
  m_NumberOfUnselectedAdded = 0;

  //create contour
  bool makeContour = false;
  this->GetDataNode()->GetBoolProperty("show contour", makeContour);
  if (makeContour)
  {
    this->CreateContour(NULL);
  }

  //now fill selected and unselected pointList
  //get size of Points in Property
  m_PointSize = 2;
  mitk::FloatProperty::Pointer pointSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("pointsize"));
  if ( pointSizeProp.IsNotNull() )
    m_PointSize = pointSizeProp->GetValue();

  //get the property for creating a label onto every point only once
  bool showLabel = true;
  this->GetDataNode()->GetBoolProperty("show label", showLabel);
  const char * pointLabel=NULL;
  if(showLabel)
  {
    if(dynamic_cast<mitk::StringProperty *>(this->GetDataNode()->GetPropertyList()->GetProperty("label")) != NULL)
      pointLabel =dynamic_cast<mitk::StringProperty *>(this->GetDataNode()->GetPropertyList()->GetProperty("label"))->GetValue();
    else
      showLabel = false;
  }


  //check if the list for the PointDataContainer is the same size as the PointsContainer. Is not, then the points were inserted manually and can not be visualized according to the PointData (selected/unselected)
  bool pointDataBroken = (itkPointSet->GetPointData()->Size() != itkPointSet->GetPoints()->Size());
  //now add an object for each point in data
  pointDataIter = itkPointSet->GetPointData()->Begin();
  for (j=0, pointsIter=itkPointSet->GetPoints()->Begin(); 
    pointsIter!=itkPointSet->GetPoints()->End();
    pointsIter++, j++)
  {
    //check for the pointtype in data and decide which geom-object to take and then add to the selected or unselected list
    int pointType;

    if(itkPointSet->GetPointData()->size() == 0 || pointDataBroken)
      pointType = mitk::PTUNDEFINED;
    else
      pointType = pointDataIter.Value().pointSpec;

#if (VTK_MAJOR_VERSION >= 5)
    vtkPolyDataAlgorithm *source;
#else
    vtkPolyDataSource *source;
#endif

    switch (pointType)
    {
    case mitk::PTUNDEFINED:
      {
        vtkSphereSource *sphere = vtkSphereSource::New();
        sphere->SetRadius(m_PointSize);
        itk::Point<float> point1 = pointsIter->Value();
        sphere->SetCenter(point1[0],point1[1],point1[2]);
        //sphere->SetCenter(pointsIter.Value()[0],pointsIter.Value()[1],pointsIter.Value()[2]);

        //MouseOrientation Tool (PositionTracker)
        if(isInputDevice)
        {
          sphere->SetThetaResolution(10);
          sphere->SetPhiResolution(10);
        }
        else
        {
          sphere->SetThetaResolution(20);
          sphere->SetPhiResolution(20);
        }
        source = sphere;
      }
      break;
    case mitk::PTSTART:
      {
        vtkCubeSource *cube = vtkCubeSource::New();
        cube->SetXLength(m_PointSize/2);
        cube->SetYLength(m_PointSize/2);
        cube->SetZLength(m_PointSize/2);
        itk::Point<float> point1 = pointsIter->Value();
        cube->SetCenter(point1[0],point1[1],point1[2]);
        source = cube;
      }
      break;
    case mitk::PTCORNER:
      {
        vtkConeSource *cone = vtkConeSource::New();
        cone->SetRadius(m_PointSize);
        itk::Point<float> point1 = pointsIter->Value();
        cone->SetCenter(point1[0],point1[1],point1[2]);
        cone->SetResolution(20);
        source = cone;
      }
      break;
    case mitk::PTEDGE:
      {
        vtkCylinderSource *cylinder = vtkCylinderSource::New();
        cylinder->SetRadius(m_PointSize);
        itk::Point<float> point1 = pointsIter->Value();
        cylinder->SetCenter(point1[0],point1[1],point1[2]);
        cylinder->SetResolution(20);
        source = cylinder;
      }
      break;
    case mitk::PTEND:
      {
        vtkSphereSource *sphere = vtkSphereSource::New();
        sphere->SetRadius(m_PointSize);
        itk::Point<float> point1 = pointsIter->Value(); 
        sphere->SetThetaResolution(20);
        sphere->SetPhiResolution(20);
        source = sphere;
      }
      break;
    default:
      {
        vtkSphereSource *sphere = vtkSphereSource::New();
        sphere->SetRadius(m_PointSize);
        itk::Point<float> point1 = pointsIter->Value(); 
        sphere->SetCenter(point1[0],point1[1],point1[2]);
        sphere->SetThetaResolution(20);
        sphere->SetPhiResolution(20);
        source = sphere;
      }
      break;
    }
    if (!pointDataBroken)
    {
      if (pointDataIter.Value().selected)
      {
        m_vtkSelectedPointList->AddInput(source->GetOutput());
        ++m_NumberOfSelectedAdded;
      }
      else 
      {
        m_vtkUnselectedPointList->AddInput(source->GetOutput());
        ++m_NumberOfUnselectedAdded;
      }
    }
    else
    {
      m_vtkUnselectedPointList->AddInput(source->GetOutput());
      ++m_NumberOfUnselectedAdded;
    }

    source->Delete();

    if (showLabel)
    {
      char buffer[20];
      std::string l = pointLabel;
      if ( input->GetSize()>1 )
      {
        sprintf(buffer,"%d",j+1);
        l.append(buffer);
      }
      // Define the text for the label
      vtkVectorText *label = vtkVectorText::New();
      label->SetText(l.c_str());

      //# Set up a transform to move the label to a new position.
      vtkTransform *aLabelTransform =vtkTransform::New();
      aLabelTransform->Identity();
      itk::Point<float> point1 = pointsIter->Value();
      aLabelTransform->Translate(point1[0]+2,point1[1]+2,point1[2]);
      aLabelTransform->Scale(5.7,5.7,5.7);

      //# Move the label to a new position.
      vtkTransformPolyDataFilter *labelTransform = vtkTransformPolyDataFilter::New();
      labelTransform->SetTransform(aLabelTransform);
      aLabelTransform->Delete();
      labelTransform->SetInput(label->GetOutput());
      label->Delete();

      //add it to the wright PointList
      if (pointType)
      {
        m_vtkSelectedPointList->AddInput(labelTransform->GetOutput());
        ++m_NumberOfSelectedAdded;
      }
      else 
      {
        m_vtkUnselectedPointList->AddInput(labelTransform->GetOutput());
        ++m_NumberOfUnselectedAdded;
      }
      labelTransform->Delete();
    }

    if(pointDataIter != itkPointSet->GetPointData()->End())
      pointDataIter++;
  } // end FOR
  
  
  //now according to number of elements added to selected or unselected, build up the rendering pipeline
  if (m_NumberOfSelectedAdded > 0)
  {
    m_VtkSelectedPolyDataMapper = vtkPolyDataMapper::New();
    m_VtkSelectedPolyDataMapper->SetInput(m_vtkSelectedPointList->GetOutput());

    //create a new instance of the actor
    m_SelectedActor->Delete();
    m_SelectedActor = vtkActor::New();

    m_SelectedActor->SetMapper(m_VtkSelectedPolyDataMapper);
    m_VtkSelectedPolyDataMapper->Delete();
    m_PointsAssembly->AddPart(m_SelectedActor);
  }
  m_vtkSelectedPointList->Delete();

  if (m_NumberOfUnselectedAdded > 0)
  {
    m_VtkUnselectedPolyDataMapper = vtkPolyDataMapper::New();
    m_VtkUnselectedPolyDataMapper->SetInput(m_vtkUnselectedPointList->GetOutput());

    //create a new instance of the actor
    m_UnselectedActor->Delete();
    m_UnselectedActor = vtkActor::New();

    m_UnselectedActor->SetMapper(m_VtkUnselectedPolyDataMapper);
    m_VtkUnselectedPolyDataMapper->Delete();
    m_PointsAssembly->AddPart(m_UnselectedActor);
  }
  m_vtkUnselectedPointList->Delete();
}

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

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

Reimplemented from mitk::Mapper.

Reimplemented in mitk::SplineVtkMapper3D.

Definition at line 375 of file mitkPointSetVtkMapper3D.cpp.

{
  //create new vtk render objects (e.g. sphere for a point)
  this->CreateVTKRenderObjects();

  //apply props
  Superclass::ApplyProperties( m_ContourActor, NULL );
  this->ApplyProperties(NULL);

}

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

Generate the data needed for rendering into renderer.

Reimplemented from mitk::Mapper.

Reimplemented in mitk::LineVtkMapper3D, and mitk::SplineVtkMapper3D.

Definition at line 387 of file mitkPointSetVtkMapper3D.cpp.

References mitk::GenericProperty< T >::GetValue().

{
  SetVtkMapperImmediateModeRendering(m_VtkSelectedPolyDataMapper);
  SetVtkMapperImmediateModeRendering(m_VtkUnselectedPolyDataMapper);

  mitk::FloatProperty::Pointer pointSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("pointsize"));
  mitk::FloatProperty::Pointer contourSizeProp = dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("contoursize"));
  // only create new vtk render objects if property values were changed
  if ( pointSizeProp.IsNotNull() &&  contourSizeProp.IsNotNull() )
  {
    if (m_PointSize!=pointSizeProp->GetValue() || m_ContourRadius!= contourSizeProp->GetValue())
    {
      this->CreateVTKRenderObjects();
    }
  }


  Superclass::ApplyProperties( m_ContourActor, renderer );
  this->ApplyProperties(renderer);

  if(IsVisible(renderer)==false)
  {
    m_UnselectedActor->VisibilityOff();
    m_SelectedActor->VisibilityOff();
    m_ContourActor->VisibilityOff();
    return;
  }

  bool showPoints = true;
  this->GetDataNode()->GetBoolProperty("show points", showPoints);
  if(showPoints)
  {
    m_UnselectedActor->VisibilityOn();
    m_SelectedActor->VisibilityOn();
  }
  else
  {
    m_UnselectedActor->VisibilityOff();
    m_SelectedActor->VisibilityOff();
  }

  if(dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("opacity")) != NULL)
  {  
    mitk::FloatProperty::Pointer pointOpacity =dynamic_cast<mitk::FloatProperty *>(this->GetDataNode()->GetProperty("opacity"));
    float opacity = pointOpacity->GetValue();
    m_ContourActor->GetProperty()->SetOpacity(opacity);
    m_UnselectedActor->GetProperty()->SetOpacity(opacity);
    m_SelectedActor->GetProperty()->SetOpacity(opacity);
  }

  bool makeContour = false;
  this->GetDataNode()->GetBoolProperty("show contour", makeContour);
  if (makeContour)
  {
    m_ContourActor->VisibilityOn();
  }
  else
  {
    m_ContourActor->VisibilityOff();
  }
}

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

Reimplemented from mitk::VtkMapper3D.

Reimplemented in mitk::LineVtkMapper3D, and mitk::SplineVtkMapper3D.

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

Definition at line 52 of file mitkPointSetVtkMapper3D.cpp.

References mitk::Mapper::GetData().

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

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

Implements mitk::VtkMapper3D.

Reimplemented in mitk::SplineVtkMapper3D.

Definition at line 456 of file mitkPointSetVtkMapper3D.cpp.

{
  return m_PointsAssembly;
}

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

Reimplemented in mitk::LineVtkMapper3D, and mitk::SplineVtkMapper3D.

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

void mitk::PointSetVtkMapper3D::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 90 of file mitkPointSetVtkMapper3D.cpp.

{
  m_PointsAssembly->ReleaseGraphicsResources(renWin);

  m_SelectedActor->ReleaseGraphicsResources(renWin);
  m_UnselectedActor->ReleaseGraphicsResources(renWin);
  m_ContourActor->ReleaseGraphicsResources(renWin);
}

void mitk::PointSetVtkMapper3D::ResetMapper ( BaseRenderer * renderer ) [protected, virtual]

Reimplemented from mitk::Mapper.

Definition at line 450 of file mitkPointSetVtkMapper3D.cpp.

{
  m_PointsAssembly->VisibilityOff();
}

void mitk::PointSetVtkMapper3D::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 662 of file mitkPointSetVtkMapper3D.cpp.

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

Referenced by mitk::CoreObjectFactory::SetDefaultProperties().

{
  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, 0.0f, 0.0f), renderer, overwrite);  //red
  node->AddProperty( "color", mitk::ColorProperty::New(1.0f, 1.0f, 0.0f), renderer, overwrite);  //yellow
  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( "updateDataOnRender", mitk::BoolProperty::New(true), renderer, overwrite );  
  Superclass::SetDefaultProperties(node, renderer, overwrite);
}

void mitk::PointSetVtkMapper3D::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.

Reimplemented in mitk::SplineVtkMapper3D.

Definition at line 461 of file mitkPointSetVtkMapper3D.cpp.

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

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