diff --git a/Modules/PlanarFigure/Algorithms/mitkPlanarFigureObjectFactory.cpp b/Modules/PlanarFigure/Algorithms/mitkPlanarFigureObjectFactory.cpp
index d5fb22a7a5..3e6318dbb1 100644
--- a/Modules/PlanarFigure/Algorithms/mitkPlanarFigureObjectFactory.cpp
+++ b/Modules/PlanarFigure/Algorithms/mitkPlanarFigureObjectFactory.cpp
@@ -1,144 +1,148 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkPlanarFigureObjectFactory.h"
 #include "mitkPlanarFigureWriter.h"
 
 #include "mitkCoreObjectFactory.h"
 
 #include "mitkPlanarFigureIOFactory.h"
 #include "mitkPlanarFigureWriterFactory.h"
 #include "mitkPlanarFigure.h"
 #include "mitkPlanarFigureMapper2D.h"
+#include "mitkPlanarFigureVtkMapper3D.h"
 
 typedef std::multimap<std::string, std::string> MultimapType;
 
 mitk::PlanarFigureObjectFactory::PlanarFigureObjectFactory()
 : m_PlanarFigureIOFactory(PlanarFigureIOFactory::New().GetPointer())
 {
   static bool alreadyDone = false;
   if ( !alreadyDone )
   {
     RegisterIOFactories();
 
     itk::ObjectFactoryBase::RegisterFactory( m_PlanarFigureIOFactory );
 
     PlanarFigureWriterFactory::RegisterOneFactory();
 
     m_FileWriters.push_back( PlanarFigureWriter::New().GetPointer() );
 
     CreateFileExtensionsMap();
 
     alreadyDone = true;
   }
 }
 
 mitk::PlanarFigureObjectFactory::~PlanarFigureObjectFactory()
 {
   PlanarFigureWriterFactory::UnRegisterOneFactory();
   itk::ObjectFactoryBase::UnRegisterFactory(m_PlanarFigureIOFactory);
 }
 
 mitk::Mapper::Pointer mitk::PlanarFigureObjectFactory::CreateMapper(mitk::DataNode* node, MapperSlotId id)
 {
   mitk::Mapper::Pointer newMapper=NULL;
   mitk::BaseData *data = node->GetData();
 
-  if ( id == mitk::BaseRenderer::Standard2D )
+  if ( dynamic_cast<PlanarFigure*>(data) != NULL )
   {
-    if ( dynamic_cast<PlanarFigure*>(data) != NULL )
+    if ( id == mitk::BaseRenderer::Standard2D )
     {
       newMapper = mitk::PlanarFigureMapper2D::New();
       newMapper->SetDataNode(node);
     }
-  }
-  else if ( id == mitk::BaseRenderer::Standard3D )
-  {
+    else if ( id == mitk::BaseRenderer::Standard3D )
+    {
+      newMapper = mitk::PlanarFigureVtkMapper3D::New();
+      newMapper->SetDataNode(node);
+    }
   }
 
   return newMapper;
 }
 
 void mitk::PlanarFigureObjectFactory::SetDefaultProperties(mitk::DataNode* node)
 {
 
   if ( node == NULL )
   {
     return;
   }
 
   mitk::DataNode::Pointer nodePointer = node;
 
   mitk::PlanarFigure::Pointer pf = dynamic_cast<mitk::PlanarFigure*>( node->GetData() );
   if ( pf.IsNotNull() )
   {
     mitk::PlanarFigureMapper2D::SetDefaultProperties(node);
     node->AddProperty( "color", mitk::ColorProperty::New(1.0,1.0,1.0), NULL, true );
     node->AddProperty( "opacity", mitk::FloatProperty::New(0.8), NULL, true );
+    node->AddProperty( "planarfigure.3drendering", mitk::BoolProperty::New(false), NULL, true );
   }
 }
 
 const char* mitk::PlanarFigureObjectFactory::GetFileExtensions()
 {
   return "";
 }
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::PlanarFigureObjectFactory::GetFileExtensionsMap()
 {
   return m_FileExtensionsMap;
 }
 
 const char* mitk::PlanarFigureObjectFactory::GetSaveFileExtensions()
 {
   //return ";;Planar Figures (*.pf)";  // for mitk::PlanarFigure and derived classes
   std::string fileExtension;
   this->CreateFileExtensions(m_SaveFileExtensionsMap, fileExtension);
   return fileExtension.c_str();
 };
 
 mitk::CoreObjectFactoryBase::MultimapType mitk::PlanarFigureObjectFactory::GetSaveFileExtensionsMap()
 {
   return m_SaveFileExtensionsMap;
 }
 
 void mitk::PlanarFigureObjectFactory::CreateFileExtensionsMap()
 {
   m_FileExtensionsMap.insert(std::pair<std::string, std::string>("*.pf", "Planar Figure Files"));
   m_SaveFileExtensionsMap.insert(std::pair<std::string, std::string>("*.pf", "Planar Figure Files"));
 }
 
 void mitk::PlanarFigureObjectFactory::RegisterIOFactories()
 {
 }
 
 
 struct RegisterPlanarFigureObjectFactory{
   RegisterPlanarFigureObjectFactory()
     : m_Factory( mitk::PlanarFigureObjectFactory::New() )
   {
     mitk::CoreObjectFactory::GetInstance()->RegisterExtraFactory( m_Factory );
   }
 
   ~RegisterPlanarFigureObjectFactory()
   {
     mitk::CoreObjectFactory::GetInstance()->UnRegisterExtraFactory( m_Factory );
   }
 
   mitk::PlanarFigureObjectFactory::Pointer m_Factory;
 };
 
 static RegisterPlanarFigureObjectFactory registerPlanarFigureObjectFactory;
 
diff --git a/Modules/PlanarFigure/Rendering/mitkPlanarFigureVtkMapper3D.cpp b/Modules/PlanarFigure/Rendering/mitkPlanarFigureVtkMapper3D.cpp
index 376439529f..89735b4d78 100644
--- a/Modules/PlanarFigure/Rendering/mitkPlanarFigureVtkMapper3D.cpp
+++ b/Modules/PlanarFigure/Rendering/mitkPlanarFigureVtkMapper3D.cpp
@@ -1,184 +1,189 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #include "mitkPlanarFigureVtkMapper3D.h"
 #include <mitkPlanarFigure.h>
 #include <vtkCellArray.h>
 #include <vtkIdList.h>
 #include <vtkPoints.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkPolyLine.h>
 
 mitk::PlanarFigureVtkMapper3D::LocalStorage::LocalStorage()
   : m_Actor(vtkSmartPointer<vtkActor>::New()),
     m_LastMTime(0)
 {
 }
 
 mitk::PlanarFigureVtkMapper3D::LocalStorage::~LocalStorage()
 {
 }
 
 void mitk::PlanarFigureVtkMapper3D::SetDefaultProperties(DataNode*, BaseRenderer*, bool)
 {
 }
 
 mitk::PlanarFigureVtkMapper3D::PlanarFigureVtkMapper3D()
 {
 }
 
 mitk::PlanarFigureVtkMapper3D::~PlanarFigureVtkMapper3D()
 {
 }
 
 void mitk::PlanarFigureVtkMapper3D::ApplyColorAndOpacityProperties(BaseRenderer* renderer, vtkActor* actor)
 {
   if (actor == NULL)
     return;
 
   mitk::DataNode* dataNode = this->GetDataNode();
 
   if (dataNode == NULL)
     return;
 
   bool selected = false;
   dataNode->GetBoolProperty("selected", selected, renderer);
 
   float color[3];
   dataNode->GetColor(color, renderer, selected ? "planarfigure.selected.line.color" : "color");
 
   float opacity = 1.0f;
   dataNode->GetOpacity(opacity, renderer);
 
   vtkProperty* property = actor->GetProperty();
   property->SetColor(color[0], color[1], color[2]);
   property->SetOpacity(opacity);
 }
 
 void mitk::PlanarFigureVtkMapper3D::ApplyPlanarFigureProperties(BaseRenderer* renderer, vtkActor* actor)
 {
   if (actor == NULL)
     return;
 
   mitk::DataNode* dataNode = this->GetDataNode();
 
   if (dataNode == NULL)
     return;
 
+  bool render = false;
+  dataNode->GetBoolProperty("planarfigure.3drendering", render);
+
+  actor->SetVisibility(render);
+
   float lineWidth = 1.0f;
   dataNode->GetFloatProperty("planarfigure.line.width", lineWidth, renderer);
 
   vtkProperty* property = actor->GetProperty();
   property->SetLineWidth(lineWidth);
 }
 
 void mitk::PlanarFigureVtkMapper3D::GenerateDataForRenderer(BaseRenderer* renderer)
 {
   typedef PlanarFigure::PolyLineType PolyLine;
 
   DataNode* node = this->GetDataNode();
 
   if (node == NULL)
     return;
 
   PlanarFigure* planarFigure = dynamic_cast<PlanarFigure*>(node->GetData());
 
   if (planarFigure == NULL || !planarFigure->IsPlaced())
     return;
 
   LocalStorage* localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
   unsigned long mTime = planarFigure->GetMTime();
 
   if (mTime > localStorage->m_LastMTime)
   {
     localStorage->m_LastMTime = mTime;
 
     const PlaneGeometry* planeGeometry = dynamic_cast<const PlaneGeometry*>(planarFigure->GetGeometry2D());
 
     if (planeGeometry == NULL)
       return;
 
     size_t numPolyLines = planarFigure->GetPolyLinesSize();
 
     if (numPolyLines == 0)
       return;
 
     vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
     vtkIdType baseIndex = 0;
 
     for (size_t i = 0; i < numPolyLines; ++i)
     {
       PolyLine polyLine = planarFigure->GetPolyLine(i);
       vtkIdType numPoints = polyLine.size();
 
       if (numPoints < 2)
         continue;
 
       PolyLine::const_iterator polyLineEnd = polyLine.end();
 
       for (PolyLine::const_iterator polyLineIt = polyLine.begin(); polyLineIt != polyLineEnd; ++polyLineIt)
       {
         Point3D point;
         planeGeometry->Map(polyLineIt->Point, point);
         points->InsertNextPoint(point.GetDataPointer());
       }
 
       vtkSmartPointer<vtkPolyLine> line = vtkSmartPointer<vtkPolyLine>::New();
 
       vtkIdList* pointIds = line->GetPointIds();
 
       if (planarFigure->IsClosed() && numPoints > 2)
       {
         pointIds->SetNumberOfIds(numPoints + 1);
         pointIds->SetId(numPoints, baseIndex);
       }
       else
       {
         pointIds->SetNumberOfIds(numPoints);
       }
 
       for (vtkIdType j = 0; j < numPoints; ++j)
         pointIds->SetId(j, baseIndex + j);
 
       cells->InsertNextCell(line);
 
       baseIndex += points->GetNumberOfPoints();
     }
 
     vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
     polyData->SetPoints(points);
     polyData->SetLines(cells);
 
     vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     mapper->SetInput(polyData);
 
     localStorage->m_Actor->SetMapper(mapper);
   }
 
   this->ApplyColorAndOpacityProperties(renderer, localStorage->m_Actor);
   this->ApplyPlanarFigureProperties(renderer, localStorage->m_Actor);
 }
 
 vtkProp* mitk::PlanarFigureVtkMapper3D::GetVtkProp(BaseRenderer* renderer)
 {
   return m_LocalStorageHandler.GetLocalStorage(renderer)->m_Actor;
 }
 
 void mitk::PlanarFigureVtkMapper3D::UpdateVtkTransform(BaseRenderer*)
 {
 }