diff --git a/Modules/Simulation/mitkSetVtkRendererVisitor.cpp b/Modules/Simulation/mitkSetVtkRendererVisitor.cpp
index 5b16630a27..4bb04053ca 100644
--- a/Modules/Simulation/mitkSetVtkRendererVisitor.cpp
+++ b/Modules/Simulation/mitkSetVtkRendererVisitor.cpp
@@ -1,58 +1,42 @@
 /*===================================================================
 
 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 "mitkSetVtkRendererVisitor.h"
 #include "mitkVtkModel.h"
 
 mitk::SetVtkRendererVisitor::SetVtkRendererVisitor(vtkRenderer* renderer, const sofa::core::ExecParams* params)
   : Visitor(params),
-    m_VtkRenderer(renderer),
-    m_RenderingMode(VtkModel::Default)
-{
-}
-
-mitk::SetVtkRendererVisitor::SetVtkRendererVisitor(vtkRenderer* renderer, const Point3D& planePoint, const Vector3D& planeNormal, ScalarType planeThickness, const sofa::core::ExecParams* params)
-  : Visitor(params),
-    m_RenderingMode(VtkModel::ClippingPlanes),
-    m_PlanePoint(planePoint),
-    m_PlaneNormal(planeNormal),
-    m_PlaneThickness(planeThickness)
+    m_VtkRenderer(renderer)
 {
 }
 
 mitk::SetVtkRendererVisitor::~SetVtkRendererVisitor()
 {
 }
 
 sofa::simulation::Visitor::Result mitk::SetVtkRendererVisitor::processNodeTopDown(sofa::simulation::Node* node)
 {
   for_each(this, node, node->visualModel, &SetVtkRendererVisitor::processVisualModel);
   return RESULT_CONTINUE;
 }
 
 void mitk::SetVtkRendererVisitor::processVisualModel(sofa::simulation::Node*, sofa::core::visual::VisualModel* visualModel)
 {
   VtkModel* vtkModel = dynamic_cast<VtkModel*>(visualModel);
 
   if (vtkModel != NULL)
-  {
     vtkModel->SetVtkRenderer(m_VtkRenderer);
-    vtkModel->SetRenderingMode(m_RenderingMode);
-
-    if (m_RenderingMode == VtkModel::ClippingPlanes)
-      vtkModel->SetPlane(m_PlanePoint, m_PlaneNormal, m_PlaneThickness);
-  }
 }
diff --git a/Modules/Simulation/mitkSetVtkRendererVisitor.h b/Modules/Simulation/mitkSetVtkRendererVisitor.h
index 89ef566879..93ebc0d385 100644
--- a/Modules/Simulation/mitkSetVtkRendererVisitor.h
+++ b/Modules/Simulation/mitkSetVtkRendererVisitor.h
@@ -1,51 +1,45 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef mitkSetVtkRendererVisitor_h
 #define mitkSetVtkRendererVisitor_h
 
-#include <mitkVtkModel.h>
 #include <sofa/simulation/common/Visitor.h>
 #include <MitkSimulationExports.h>
 
 class vtkRenderer;
 
 namespace mitk
 {
   class MitkSimulation_EXPORT SetVtkRendererVisitor : public sofa::simulation::Visitor
   {
   public:
     explicit SetVtkRendererVisitor(vtkRenderer* renderer, const sofa::core::ExecParams* params = sofa::core::ExecParams::defaultInstance());
-    SetVtkRendererVisitor(vtkRenderer* renderer, const Point3D& planePoint, const Vector3D& planeNormal, ScalarType planeThickness = 1.0, const sofa::core::ExecParams* params = sofa::core::ExecParams::defaultInstance());
     ~SetVtkRendererVisitor();
 
     Result processNodeTopDown(sofa::simulation::Node* node);
 
   private:
     SetVtkRendererVisitor(const SetVtkRendererVisitor&);
     SetVtkRendererVisitor& operator=(const SetVtkRendererVisitor&);
 
     void processVisualModel(sofa::simulation::Node*, sofa::core::visual::VisualModel* visualModel);
 
     vtkRenderer* m_VtkRenderer;
-    VtkModel::RenderingMode m_RenderingMode;
-    Point3D m_PlanePoint;
-    Vector3D m_PlaneNormal;
-    ScalarType m_PlaneThickness;
   };
 }
 
 #endif
diff --git a/Modules/Simulation/mitkSimulationGLMapper2D.cpp b/Modules/Simulation/mitkSimulationGLMapper2D.cpp
index 7b93d3e4b2..254c57e640 100644
--- a/Modules/Simulation/mitkSimulationGLMapper2D.cpp
+++ b/Modules/Simulation/mitkSimulationGLMapper2D.cpp
@@ -1,81 +1,69 @@
 /*===================================================================
 
 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 "mitkGetSimulationService.h"
 #include "mitkISimulationService.h"
 #include "mitkSetVtkRendererVisitor.h"
 #include "mitkSimulation.h"
 #include "mitkSimulationGLMapper2D.h"
 #include <sofa/core/visual/VisualParams.h>
 
 void mitk::SimulationGLMapper2D::SetDefaultProperties(DataNode* node, BaseRenderer* renderer, bool overwrite)
 {
   if (node != NULL)
   {
     Superclass::SetDefaultProperties(node, renderer, overwrite);
   }
 }
 
 mitk::SimulationGLMapper2D::SimulationGLMapper2D()
   : m_SimulationService(GetSimulationService())
 {
 }
 
 mitk::SimulationGLMapper2D::~SimulationGLMapper2D()
 {
 }
 
 void mitk::SimulationGLMapper2D::ApplyColorAndOpacityProperties(BaseRenderer*, vtkActor*)
 {
 }
 
 void mitk::SimulationGLMapper2D::Paint(BaseRenderer* renderer)
 {
   if (renderer == NULL)
     return;
 
   SliceNavigationController* sliceNavigationController = renderer->GetSliceNavigationController();
 
   if (sliceNavigationController == NULL)
     return;
 
   const PlaneGeometry* planeGeometry = sliceNavigationController->GetCurrentPlaneGeometry();
 
   if (planeGeometry == NULL)
     return;
 
   DataNode* dataNode = this->GetDataNode();
 
   if (dataNode == NULL)
     return;
 
   Simulation* simulation = static_cast<Simulation*>(dataNode->GetData());
 
   if (simulation == NULL)
     return;
-
-  SetVtkRendererVisitor setVtkRendererVisitor(renderer->GetVtkRenderer(), planeGeometry->GetOrigin(), planeGeometry->GetNormal());
-  simulation->GetRootNode()->executeVisitor(&setVtkRendererVisitor);
-
-  m_SimulationService->SetActiveSimulation(simulation);
-
-  sofa::core::visual::VisualParams* vParams = sofa::core::visual::VisualParams::defaultInstance();
-  sofa::simulation::Simulation::SPtr sofaSimulation = simulation->GetSOFASimulation();
-  sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode();
-
-  sofaSimulation->updateVisual(rootNode.get()); // TODO: Check if this is happening only once per time step.
-  sofaSimulation->draw(vParams, rootNode.get());
 }
diff --git a/Modules/Simulation/mitkSimulationVtkMapper3D.cpp b/Modules/Simulation/mitkSimulationVtkMapper3D.cpp
index 6276f50e63..369077e42f 100644
--- a/Modules/Simulation/mitkSimulationVtkMapper3D.cpp
+++ b/Modules/Simulation/mitkSimulationVtkMapper3D.cpp
@@ -1,164 +1,164 @@
 /*===================================================================
 
 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 "mitkSetVtkRendererVisitor.h"
 #include "mitkSimulation.h"
 #include "mitkSimulationVtkMapper3D.h"
 #include "mitkVtkSimulationPolyDataMapper.h"
 #include <sofa/component/visualmodel/VisualStyle.h>
 #include <sofa/core/visual/VisualParams.h>
 
 mitk::SimulationVtkMapper3D::LocalStorage::LocalStorage()
   : m_Actor(vtkSmartPointer<vtkActor>::New())
 {
 }
 
 mitk::SimulationVtkMapper3D::LocalStorage::~LocalStorage()
 {
 }
 
 void mitk::SimulationVtkMapper3D::SetDefaultProperties(DataNode* node, BaseRenderer* renderer, bool overwrite)
 {
   if (node != NULL)
   {
     Simulation* simulation = dynamic_cast<Simulation*>(node->GetData());
 
     if (simulation != NULL)
     {
       sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode();
       sofa::component::visualmodel::VisualStyle::SPtr visualStyle;
 
       rootNode->get(visualStyle);
 
       if (!visualStyle)
       {
         visualStyle = sofa::core::objectmodel::New<sofa::component::visualmodel::VisualStyle>();
 
         sofa::core::visual::DisplayFlags* displayFlags = visualStyle->displayFlags.beginEdit();
         displayFlags->setShowVisualModels();
         visualStyle->displayFlags.endEdit();
 
         rootNode->addObject(visualStyle);
       }
 
       const sofa::core::visual::DisplayFlags& displayFlags = visualStyle->displayFlags.getValue();
 
       node->AddProperty("Simulation.Behavior.Behavior Models", BoolProperty::New(displayFlags.getShowBehaviorModels()), renderer, overwrite);
       node->AddProperty("Simulation.Behavior.Force Fields", BoolProperty::New(displayFlags.getShowForceFields()), renderer, overwrite);
       node->AddProperty("Simulation.Behavior.Interactions", BoolProperty::New(displayFlags.getShowInteractionForceFields()), renderer, overwrite);
       node->AddProperty("Simulation.Collision.Bounding Trees", BoolProperty::New(displayFlags.getShowBoundingCollisionModels()), renderer, overwrite);
       node->AddProperty("Simulation.Collision.Collision Models", BoolProperty::New(displayFlags.getShowCollisionModels()), renderer, overwrite);
       node->AddProperty("Simulation.Mapping.Mechanical Mappings", BoolProperty::New(displayFlags.getShowMechanicalMappings()), renderer, overwrite);
       node->AddProperty("Simulation.Mapping.Visual Mappings", BoolProperty::New(displayFlags.getShowMappings()), renderer, overwrite);
       node->AddProperty("Simulation.Options.Normals", BoolProperty::New(displayFlags.getShowNormals()), renderer, overwrite);
       node->AddProperty("Simulation.Options.Wire Frame", BoolProperty::New(displayFlags.getShowWireFrame()), renderer, overwrite);
       node->AddProperty("Simulation.Visual.Visual Models", BoolProperty::New(displayFlags.getShowVisualModels() != sofa::core::visual::tristate::false_value), renderer, overwrite);
     }
 
     Superclass::SetDefaultProperties(node, renderer, overwrite);
   }
 }
 
 mitk::SimulationVtkMapper3D::SimulationVtkMapper3D()
 {
 }
 
 mitk::SimulationVtkMapper3D::~SimulationVtkMapper3D()
 {
 }
 
 void mitk::SimulationVtkMapper3D::ApplyColorAndOpacityProperties(vtkActor*, BaseRenderer*)
 {
 }
 
 void mitk::SimulationVtkMapper3D::ApplySimulationProperties(BaseRenderer* renderer)
 {
   DataNode* node = this->GetDataNode();
 
   bool showBehaviorModels;
   bool showForceFields;
   bool showInteractionForceFields;
   bool showBoundingCollisionModels;
   bool showCollisionModels;
   bool showMechanicalMappings;
   bool showMappings;
   bool showNormals;
   bool showWireFrame;
   bool showVisualModels;
 
   node->GetBoolProperty("Simulation.Behavior.Behavior Models", showBehaviorModels, renderer);
   node->GetBoolProperty("Simulation.Behavior.Force Fields", showForceFields, renderer);
   node->GetBoolProperty("Simulation.Behavior.Interactions", showInteractionForceFields, renderer);
   node->GetBoolProperty("Simulation.Collision.Bounding Trees", showBoundingCollisionModels, renderer);
   node->GetBoolProperty("Simulation.Collision.Collision Models", showCollisionModels, renderer);
   node->GetBoolProperty("Simulation.Mapping.Mechanical Mappings", showMechanicalMappings, renderer);
   node->GetBoolProperty("Simulation.Mapping.Visual Mappings", showMappings, renderer);
   node->GetBoolProperty("Simulation.Options.Normals", showNormals, renderer);
   node->GetBoolProperty("Simulation.Options.Wire Frame", showWireFrame, renderer);
   node->GetBoolProperty("Simulation.Visual.Visual Models", showVisualModels, renderer);
 
   Simulation* simulation = static_cast<Simulation*>(this->GetData());
   sofa::component::visualmodel::VisualStyle::SPtr visualStyle;
   simulation->GetRootNode()->get(visualStyle);
 
   sofa::core::visual::DisplayFlags* displayFlags = visualStyle->displayFlags.beginEdit();
 
   displayFlags->setShowBehaviorModels(showBehaviorModels);
   displayFlags->setShowForceFields(showForceFields);
   displayFlags->setShowInteractionForceFields(showInteractionForceFields);
   displayFlags->setShowBoundingCollisionModels(showBoundingCollisionModels);
   displayFlags->setShowCollisionModels(showCollisionModels);
   displayFlags->setShowMechanicalMappings(showMechanicalMappings);
   displayFlags->setShowMappings(showMappings);
   displayFlags->setShowNormals(showNormals);
   displayFlags->setShowWireFrame(showWireFrame);
   displayFlags->setShowVisualModels(showVisualModels);
 
   visualStyle->displayFlags.endEdit();
 }
 
 void mitk::SimulationVtkMapper3D::GenerateDataForRenderer(BaseRenderer* renderer)
 {
   DataNode* dataNode = this->GetDataNode();
 
   if (dataNode == NULL)
     return;
 
   Simulation* simulation = static_cast<Simulation*>(dataNode->GetData());
 
   if (simulation == NULL)
     return;
 
   LocalStorage* localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
 
   if (localStorage->m_Mapper == NULL)
   {
     localStorage->m_Mapper = vtkSmartPointer<vtkSimulationPolyDataMapper>::New();
     localStorage->m_Mapper->SetSimulation(simulation);
 
     localStorage->m_Actor->SetMapper(localStorage->m_Mapper);
-  }
 
-  SetVtkRendererVisitor setVtkRendererVisitor(renderer->GetVtkRenderer());
-  simulation->GetRootNode()->executeVisitor(&setVtkRendererVisitor);
+    SetVtkRendererVisitor setVtkRendererVisitor(renderer->GetVtkRenderer());
+    simulation->GetRootNode()->executeVisitor(&setVtkRendererVisitor);
+  }
 
   this->ApplySimulationProperties(renderer);
 }
 
 vtkProp* mitk::SimulationVtkMapper3D::GetVtkProp(BaseRenderer* renderer)
 {
   return m_LocalStorageHandler.GetLocalStorage(renderer)->m_Actor;
 }
diff --git a/Modules/Simulation/mitkVtkModel.cpp b/Modules/Simulation/mitkVtkModel.cpp
index 54c929625b..83e493433e 100644
--- a/Modules/Simulation/mitkVtkModel.cpp
+++ b/Modules/Simulation/mitkVtkModel.cpp
@@ -1,430 +1,390 @@
 /*===================================================================
 
 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 "mitkVtkModel.h"
 #include <mitkLogMacros.h>
 #include <sofa/core/visual/VisualParams.h>
 #include <vtkImageData.h>
 #include <vtkImageReader2.h>
 #include <vtkImageReader2Factory.h>
 #include <vtkOpenGLTexture.h>
 
 bool mitk::VtkModel::IsGlewInitialized = false;
 
 mitk::VtkModel::VtkModel()
   : m_BuffersCreated(false),
     m_LastNumberOfVertices(0),
     m_LastNumberOfTriangles(0),
     m_LastNumberOfQuads(0),
     m_VertexBuffer(0),
     m_IndexBuffer(0),
-    m_VtkRenderer(NULL),
-    m_RenderingMode(Default)
+    m_VtkRenderer(NULL)
 {
   if (!IsGlewInitialized)
   {
     GLenum error = glewInit();
 
     if (error != GLEW_OK)
       MITK_ERROR("glewInit") << glewGetErrorString(error);
     else
       IsGlewInitialized = true;
   }
 }
 
 mitk::VtkModel::~VtkModel()
 {
   /*if (m_BuffersCreated)
   {
     glDeleteBuffers(1, &m_IndexBuffer);
     glDeleteBuffers(1, &m_VertexBuffer);
   }*/
 }
 
 void mitk::VtkModel::CreateIndexBuffer()
 {
   glGenBuffers(1, &m_IndexBuffer);
   this->InitIndexBuffer();
 }
 
 void mitk::VtkModel::CreateVertexBuffer()
 {
   glGenBuffers(1, &m_VertexBuffer);
   this->InitVertexBuffer();
 }
 
 void mitk::VtkModel::DrawGroup(int group, bool)
 {
   using sofa::core::loader::Material;
   using sofa::defaulttype::ResizableExtVector;
   using sofa::defaulttype::Vec4f;
 
   const VecCoord& vertices = this->getVertices();
   const ResizableExtVector<Deriv>& normals = this->getVnormals();
   const ResizableExtVector<Triangle>& triangles = this->getTriangles();
   const ResizableExtVector<Quad>& quads = this->getQuads();
 
   FaceGroup faceGroup;
 
   if (group == -1)
   {
     faceGroup.nbt = triangles.size();
     faceGroup.nbq = quads.size();
   }
   else
   {
     faceGroup = groups.getValue()[group];
   }
 
   Material material = faceGroup.materialId != -1
     ? materials.getValue()[faceGroup.materialId]
     : this->material.getValue();
 
   if (material.useTexture && material.activated)
   {
     m_Textures[faceGroup.materialId]->Load(m_VtkRenderer);
 
     glEnable(GL_TEXTURE_2D);
     glTexCoordPointer(2, GL_FLOAT, 0, reinterpret_cast<const GLvoid*>(vertices.size() * sizeof(VecCoord::value_type) + normals.size() * sizeof(Deriv)));
     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
   }
 
   Vec4f ambient = material.useAmbient ? material.ambient : Vec4f();
   Vec4f diffuse = material.useDiffuse ? material.diffuse : Vec4f();
   Vec4f specular = material.useSpecular ? material.specular : Vec4f();
   Vec4f emissive = material.useEmissive ? material.emissive : Vec4f();
   float shininess = material.useShininess ? std::min(material.shininess, 128.0f) : 45.0f;
 
   if (shininess == 0.0f)
   {
     specular.clear();
     shininess = 1.0f;
   }
 
   glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, ambient.ptr());
   glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, diffuse.ptr());
   glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, specular.ptr());
   glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emissive.ptr());
   glMaterialf(GL_FRONT_AND_BACK, GL_SHININESS, shininess);
 
   if (faceGroup.nbt != 0)
     glDrawElements(GL_TRIANGLES, faceGroup.nbt * 3, GL_UNSIGNED_INT, reinterpret_cast<const GLvoid*>(faceGroup.tri0 * sizeof(Triangle)));
 
   if (faceGroup.nbq != 0)
     glDrawElements(GL_QUADS, faceGroup.nbq * 4, GL_UNSIGNED_INT, reinterpret_cast<const GLvoid*>(triangles.size() * sizeof(Triangle) + faceGroup.quad0 * sizeof(Quad)));
 
   if (material.useTexture && material.activated)
   {
     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
     glDisable(GL_TEXTURE_2D);
 
     m_Textures[faceGroup.materialId]->PostRender(m_VtkRenderer);
   }
 }
 
 void mitk::VtkModel::DrawGroups(bool transparent)
 {
   using sofa::core::objectmodel::Data;
   using sofa::helper::ReadAccessor;
   using sofa::helper::vector;
 
   ReadAccessor<Data<vector<FaceGroup> > > groups = this->groups;
 
   if (groups.empty())
   {
     this->DrawGroup(-1, transparent);
   }
   else
   {
     int numGroups = static_cast<int>(groups.size());
 
     for (int i = 0; i < numGroups; ++i)
       this->DrawGroup(i, transparent);
   }
 }
 
 void mitk::VtkModel::InitIndexBuffer()
 {
   using sofa::defaulttype::ResizableExtVector;
 
   const ResizableExtVector<Triangle>& triangles = this->getTriangles();
   const ResizableExtVector<Quad>& quads = this->getQuads();
 
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_IndexBuffer);
   glBufferData(GL_ELEMENT_ARRAY_BUFFER, triangles.size() * sizeof(Triangle) + quads.size() * sizeof(Quad), NULL, GL_DYNAMIC_DRAW);
 
   this->UpdateIndexBuffer();
 }
 
 void mitk::VtkModel::InitVertexBuffer()
 {
   using sofa::defaulttype::ResizableExtVector;
 
   const VecCoord& vertices = this->getVertices();
   const ResizableExtVector<Deriv> normals = this->getVnormals();
   const VecTexCoord& texCoords = this->getVtexcoords();
 
   GLsizeiptr sizeOfVertices = vertices.size() * sizeof(VecCoord::value_type);
   GLsizeiptr sizeOfNormals = normals.size() * sizeof(Deriv);
   GLsizeiptr sizeOfTexCoords = texCoords.size() * sizeof(VecTexCoord::value_type);
 
   glBindBuffer(GL_ARRAY_BUFFER, m_VertexBuffer);
   glBufferData(GL_ARRAY_BUFFER, sizeOfVertices + sizeOfNormals + sizeOfTexCoords, NULL, GL_DYNAMIC_DRAW);
 
   this->UpdateVertexBuffer();
 }
 
 void mitk::VtkModel::internalDraw(const sofa::core::visual::VisualParams* vparams, bool transparent)
 {
   using sofa::core::visual::DisplayFlags;
   using sofa::defaulttype::ResizableExtVector;
 
   if (!IsGlewInitialized)
     return;
 
   const DisplayFlags& displayFlags = vparams->displayFlags();
 
   if (!displayFlags.getShowVisualModels())
     return;
 
-  if (m_RenderingMode == ClippingPlanes)
-  {
-    glClipPlane(GL_CLIP_PLANE0, m_ClippingPlaneEquation0);
-    glEnable(GL_CLIP_PLANE0);
-
-    glClipPlane(GL_CLIP_PLANE1, m_ClippingPlaneEquation1);
-    glEnable(GL_CLIP_PLANE1);
-  }
-
   glEnable(GL_LIGHTING);
   glColor3f(1.0f, 1.0f, 1.0f);
   glPolygonMode(GL_FRONT_AND_BACK, displayFlags.getShowWireFrame() ? GL_LINE : GL_FILL);
 
   const VecCoord& vertices = this->getVertices();
   const ResizableExtVector<Deriv>& normals = this->getVnormals();
   const VecTexCoord& texCoords = this->getVtexcoords();
 
   glBindBuffer(GL_ARRAY_BUFFER, m_VertexBuffer);
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_IndexBuffer);
   glVertexPointer(3, GL_FLOAT, 0, NULL);
   glNormalPointer(GL_FLOAT, 0, reinterpret_cast<const GLvoid*>(vertices.size() * sizeof(VecCoord::value_type)));
   glEnableClientState(GL_VERTEX_ARRAY);
   glEnableClientState(GL_NORMAL_ARRAY);
 
   this->DrawGroups(transparent);
 
   glDisableClientState(GL_NORMAL_ARRAY);
   glDisableClientState(GL_VERTEX_ARRAY);
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
   glBindBuffer(GL_ARRAY_BUFFER, 0);
 
   if (displayFlags.getShowWireFrame())
     glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 
   glDisable(GL_LIGHTING);
 
   if (displayFlags.getShowNormals())
     this->DrawNormals();
-
-  if (m_RenderingMode == ClippingPlanes)
-  {
-    glDisable(GL_CLIP_PLANE1);
-    glDisable(GL_CLIP_PLANE0);
-  }
 }
 
 void mitk::VtkModel::DrawNormals()
 {
   using sofa::defaulttype::ResizableExtVector;
 
   const VecCoord& vertices = this->getVertices();
   const ResizableExtVector<Deriv>& normals = this->getVnormals();
   size_t numVertices = vertices.size();
   Coord normal;
 
   glBegin(GL_LINES);
 
   for (size_t i = 0; i < numVertices; ++i)
   {
     glVertex3fv(vertices[i].ptr());
     normal = vertices[i] + normals[i];
     glVertex3fv(normal.ptr());
   }
 
   glEnd();
 }
 
 bool mitk::VtkModel::loadTextures()
 {
   using sofa::helper::system::DataRepository;
   using sofa::helper::vector;
   using sofa::core::loader::Material;
 
   m_Textures.clear();
 
   std::vector<unsigned int> materialIndices;
 
   const vector<Material>& materials = this->materials.getValue();
   unsigned int numMaterials = materials.size();
 
   for (unsigned int i = 0; i < numMaterials; ++i)
   {
     const Material& material = materials[i];
 
     if (material.useTexture && material.activated)
       materialIndices.push_back(i);
   }
 
   bool retValue = true;
   size_t numTextures = materialIndices.size();
 
   for (size_t i = 0; i < numTextures; ++i)
   {
     std::string filename = materials[materialIndices[i]].textureFilename;
 
     if (!DataRepository.findFile(filename))
     {
       MITK_ERROR("VtkModel") << "File \"" << filename << "\" not found!";
       retValue = false;
       continue;
     }
 
     vtkSmartPointer<vtkImageReader2> imageReader = vtkSmartPointer<vtkImageReader2>::Take(vtkImageReader2Factory::CreateImageReader2(filename.c_str()));
 
     if (imageReader == NULL)
     {
       MITK_ERROR("VtkModel") << "File \"" << filename << "\" has unknown image format!";
       retValue = false;
       continue;
     }
 
     imageReader->SetFileName(filename.c_str());
     imageReader->UpdateWholeExtent();
 
     vtkSmartPointer<vtkOpenGLTexture> texture = vtkSmartPointer<vtkOpenGLTexture>::New();
     texture->SetInputConnection(imageReader->GetOutputPort());
     texture->InterpolateOn();
 
     m_Textures.insert(std::make_pair(materialIndices[i], texture));
   }
 
   return retValue;
 }
 
-void mitk::VtkModel::SetPlane(const Point3D& point, const Vector3D& normal, ScalarType thickness)
-{
-  Point3D point0 = point - normal * (thickness * 0.5);
-  Point3D point1 = point + normal * (thickness * 0.5);
-
-  // Plane equation: A*x + B*x + C*x + D = 0
-  // A, B, and C are the plane normal components and D is the plane distance from origin
-
-  m_ClippingPlaneEquation0[0] = normal[0];
-  m_ClippingPlaneEquation0[1] = normal[1];
-  m_ClippingPlaneEquation0[2] = normal[2];
-  m_ClippingPlaneEquation0[3] = -(normal[0] * point0[0] + normal[1] * point0[1] + normal[2] * point0[2]);
-
-  m_ClippingPlaneEquation1[0] = -normal[0];
-  m_ClippingPlaneEquation1[1] = -normal[1];
-  m_ClippingPlaneEquation1[2] = -normal[2];
-  m_ClippingPlaneEquation1[3] = normal[0] * point1[0] + normal[1] * point1[1] + normal[2] * point1[2];
-}
-
-void mitk::VtkModel::SetRenderingMode(RenderingMode renderingMode)
-{
-  m_RenderingMode = renderingMode;
-}
-
 void mitk::VtkModel::SetVtkRenderer(vtkRenderer* renderer)
 {
   m_VtkRenderer = renderer;
 }
 
 void mitk::VtkModel::updateBuffers()
 {
   using sofa::defaulttype::ResizableExtVector;
 
   const VecCoord& vertices = this->getVertices();
   const ResizableExtVector<Triangle>& triangles = this->getTriangles();
   const ResizableExtVector<Quad>& quads = this->getQuads();
 
   if (!IsGlewInitialized)
     return;
 
   if (!m_BuffersCreated)
   {
     this->CreateVertexBuffer();
     this->CreateIndexBuffer();
 
     m_BuffersCreated = true;
   }
   else
   {
     if (m_LastNumberOfVertices != vertices.size())
       this->InitVertexBuffer();
     else
       this->UpdateVertexBuffer();
 
     if (m_LastNumberOfTriangles != triangles.size() || m_LastNumberOfQuads != quads.size())
       this->InitIndexBuffer();
     else
       this->UpdateIndexBuffer();
   }
 
   m_LastNumberOfVertices = vertices.size();
   m_LastNumberOfTriangles = triangles.size();
   m_LastNumberOfQuads = quads.size();
 }
 
 void mitk::VtkModel::UpdateIndexBuffer()
 {
   using sofa::defaulttype::ResizableExtVector;
 
   const ResizableExtVector<Triangle>& triangles = this->getTriangles();
   const ResizableExtVector<Quad>& quads = this->getQuads();
 
   GLsizeiptr sizeOfTriangleIndices = triangles.size() * sizeof(Triangle);
   GLsizeiptr sizeOfQuadIndices = quads.size() * sizeof(Quad);
 
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_IndexBuffer);
   glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, sizeOfTriangleIndices, triangles.getData());
   glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, sizeOfTriangleIndices, sizeOfQuadIndices, quads.getData());
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 }
 
 void mitk::VtkModel::UpdateVertexBuffer()
 {
   using sofa::defaulttype::ResizableExtVector;
 
   const VecCoord& vertices = this->getVertices();
   const ResizableExtVector<Deriv> normals = this->getVnormals();
   const VecTexCoord& texCoords = this->getVtexcoords();
 
   GLsizeiptr sizeOfVertices = vertices.size() * sizeof(VecCoord::value_type);
   GLsizeiptr sizeOfNormals = normals.size() * sizeof(Deriv);
 
   glBindBuffer(GL_ARRAY_BUFFER, m_VertexBuffer);
   glBufferSubData(GL_ARRAY_BUFFER, 0, sizeOfVertices, vertices.getData());
   glBufferSubData(GL_ARRAY_BUFFER, sizeOfVertices, sizeOfNormals, normals.getData());
 
   if (!m_Textures.empty())
   {
     GLsizeiptr sizeOfTexCoords = texCoords.size() * sizeof(VecTexCoord::value_type);
     glBufferSubData(GL_ARRAY_BUFFER, sizeOfVertices + sizeOfNormals, sizeOfTexCoords, texCoords.getData());
   }
 
   glBindBuffer(GL_ARRAY_BUFFER, 0);
 }
diff --git a/Modules/Simulation/mitkVtkModel.h b/Modules/Simulation/mitkVtkModel.h
index 3cd3b13c7c..ebac847699 100644
--- a/Modules/Simulation/mitkVtkModel.h
+++ b/Modules/Simulation/mitkVtkModel.h
@@ -1,83 +1,72 @@
 /*===================================================================
 
 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.
 
 ===================================================================*/
 
 #ifndef mitkVtkModel_h
 #define mitkVtkModel_h
 
 #include <mitkPoint.h>
 #include <mitkVector.h>
 #include <sofa/component/visualmodel/VisualModelImpl.h>
 #include <sofa/helper/system/gl.h>
 #include <vtkSmartPointer.h>
 #include <MitkSimulationExports.h>
 
 class vtkOpenGLTexture;
 class vtkRenderer;
 
 namespace mitk
 {
   class MitkSimulation_EXPORT VtkModel : public sofa::component::visualmodel::VisualModelImpl
   {
   public:
     SOFA_CLASS(VtkModel, sofa::component::visualmodel::VisualModelImpl);
 
-    enum RenderingMode
-    {
-      Default,
-      ClippingPlanes
-    };
-
     void internalDraw(const sofa::core::visual::VisualParams* vparams, bool transparent);
     bool loadTextures();
-    void SetRenderingMode(RenderingMode renderingMode);
-    void SetPlane(const Point3D& point, const Vector3D& normal, ScalarType thickness = 1.0);
     void SetVtkRenderer(vtkRenderer* renderer);
     void updateBuffers();
 
   private:
     static bool IsGlewInitialized;
 
     VtkModel();
     ~VtkModel();
 
     VtkModel(MyType&);
     MyType& operator=(const MyType&);
 
     void CreateIndexBuffer();
     void CreateVertexBuffer();
     void DrawGroup(int group, bool);
     void DrawGroups(bool transparent);
     void DrawNormals();
     void InitIndexBuffer();
     void InitVertexBuffer();
     void UpdateIndexBuffer();
     void UpdateVertexBuffer();
 
     bool m_BuffersCreated;
     size_t m_LastNumberOfVertices;
     size_t m_LastNumberOfTriangles;
     size_t m_LastNumberOfQuads;
     GLuint m_VertexBuffer;
     GLuint m_IndexBuffer;
     std::map<unsigned int, vtkSmartPointer<vtkOpenGLTexture> > m_Textures;
     vtkRenderer* m_VtkRenderer;
-    RenderingMode m_RenderingMode;
-    GLdouble m_ClippingPlaneEquation0[4];
-    GLdouble m_ClippingPlaneEquation1[4];
   };
 }
 
 #endif