diff --git a/Modules/Simulation/mitkSimulationDrawTool.cpp b/Modules/Simulation/mitkSimulationDrawTool.cpp
index 55e5a6e5e1..69687e89c4 100644
--- a/Modules/Simulation/mitkSimulationDrawTool.cpp
+++ b/Modules/Simulation/mitkSimulationDrawTool.cpp
@@ -1,646 +1,577 @@
 /*===================================================================
 
 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 "mitkSimulation.h"
 #include "mitkSimulationDrawTool.h"
-#include <vtkActor.h>
 #include <vtkCellArray.h>
 #include <vtkCellData.h>
 #include <vtkFloatArray.h>
 #include <vtkLineSource.h>
 #include <vtkPointData.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkPolyDataNormals.h>
 #include <vtkProperty.h>
 #include <vtkSphereSource.h>
 #include <vtkTubeFilter.h>
 
 mitk::SimulationDrawTool::SimulationDrawTool()
   : m_PolygonMode(0),
     m_Wireframe(false),
     m_Update(true)
 {
 }
 
 mitk::SimulationDrawTool::~SimulationDrawTool()
 {
-  this->DeleteVtkObjects();
-}
-
-void mitk::SimulationDrawTool::DeleteVtkObjects()
-{
-  for (std::vector<vtkObjectBase*>::const_iterator object = m_VtkObjects.begin(); object != m_VtkObjects.end(); ++object)
-    (*object)->Delete();
-
-  m_VtkObjects.clear();
-
-  for (std::vector<vtkActor*>::const_iterator actor = m_Actors.begin(); actor != m_Actors.end(); ++actor)
-    (*actor)->Delete();
-
   m_Actors.clear();
 }
 
 void mitk::SimulationDrawTool::DisableUpdate()
 {
   m_Update = false;
 }
 
-
-std::vector<vtkActor*> mitk::SimulationDrawTool::GetActors() const
+std::vector<vtkSmartPointer<vtkActor> > mitk::SimulationDrawTool::GetActors() const
 {
   return m_Actors;
 }
 
 void mitk::SimulationDrawTool::InitProperty(vtkProperty* property) const
 {
   if (m_Wireframe)
     property->SetRepresentationToWireframe();
   else
     property->SetRepresentationToSurface();
 }
 
 void mitk::SimulationDrawTool::Reset()
 {
-  this->DeleteVtkObjects();
+  m_Actors.clear();
   m_Update = true;
 }
 
 void mitk::SimulationDrawTool::drawPoints(const std::vector<Vector3>& points, float pointSize, const Vec4f color)
 {
   if (!m_Update || points.empty())
     return;
 
   unsigned int numPoints = points.size();
 
-  vtkPoints* vtkPoints = vtkPoints::New();
+  vtkSmartPointer<vtkPoints> vtkPoints = vtkSmartPointer<::vtkPoints>::New();
   vtkPoints->SetNumberOfPoints(numPoints);
 
-  vtkCellArray* cellArray = vtkCellArray::New();
+  vtkSmartPointer<vtkCellArray> cellArray = vtkSmartPointer<vtkCellArray>::New();
 
   for (unsigned int i = 0; i < numPoints; ++i)
   {
     vtkPoints->SetPoint(i, points[i].elems);
     cellArray->InsertNextCell(1);
     cellArray->InsertCellPoint(i);
   }
 
-  vtkPolyData* polyData = vtkPolyData::New();
+  vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   polyData->SetPoints(vtkPoints);
   polyData->SetVerts(cellArray);
 
-  vtkPoints->Delete();
-  cellArray->Delete();
-
-  vtkPolyDataMapper* polyDataMapper = vtkPolyDataMapper::New();
+  vtkSmartPointer<vtkPolyDataMapper> polyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   polyDataMapper->SetInput(polyData);
 
-  vtkActor* actor = vtkActor::New();
+  vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
   actor->SetMapper(polyDataMapper);
   actor->SetScale(Simulation::ScaleFactor);
 
   vtkProperty* property = actor->GetProperty();
   property->SetColor(color.x(), color.y(), color.z());
   property->SetPointSize(pointSize);
 
-  m_VtkObjects.push_back(polyData);
-  m_VtkObjects.push_back(polyDataMapper);
   m_Actors.push_back(actor);
 }
 
 void mitk::SimulationDrawTool::drawLines(const std::vector<Vector3>& points, float lineWidth, const Vec4f color)
 {
   if (!m_Update || points.empty())
     return;
 
   unsigned int numPoints = points.size();
   std::vector<Vec2i> indices;
 
   for (unsigned int i = 0; i < numPoints; i += 2)
     indices.push_back(Vec2i(i, i + 1));
 
   this->drawLines(points, indices, lineWidth, color);
 }
 
 void mitk::SimulationDrawTool::drawLines(const std::vector<Vector3>& points, const std::vector<Vec2i>& indices, float lineWidth, const Vec4f color)
 {
   if (!m_Update || points.empty())
     return;
 
   unsigned int numPoints = points.size();
 
-  vtkPoints* vtkPoints = vtkPoints::New();
+  vtkSmartPointer<vtkPoints> vtkPoints = vtkSmartPointer<::vtkPoints>::New();
   vtkPoints->SetNumberOfPoints(numPoints);
 
   for (unsigned int i = 0; i < numPoints; ++i)
     vtkPoints->SetPoint(i, points[i].elems);
 
-  vtkPolyData* polyData = vtkPolyData::New();
+  vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   polyData->SetPoints(vtkPoints);
 
-  vtkPoints->Delete();
-
-  vtkCellArray* lines = vtkCellArray::New();
+  vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
 
   unsigned int numIndices = indices.size();
 
   for (unsigned int i = 0; i < numIndices; ++i)
   {
     lines->InsertNextCell(2);
     lines->InsertCellPoint(indices[i].elems[0]);
     lines->InsertCellPoint(indices[i].elems[1]);
   }
 
   polyData->SetLines(lines);
 
-  lines->Delete();
-
-  vtkPolyDataMapper* polyDataMapper = vtkPolyDataMapper::New();
+  vtkSmartPointer<vtkPolyDataMapper> polyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   polyDataMapper->SetInput(polyData);
 
-  vtkActor* actor = vtkActor::New();
+  vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
   actor->SetMapper(polyDataMapper);
   actor->SetScale(Simulation::ScaleFactor);
 
   vtkProperty* property = actor->GetProperty();
   property->SetLineWidth(lineWidth);
   property->SetColor(color.x(), color.y(), color.z());
 
-  m_VtkObjects.push_back(polyData);
-  m_VtkObjects.push_back(polyDataMapper);
   m_Actors.push_back(actor);
 }
 
 void mitk::SimulationDrawTool::drawTriangles(const std::vector<Vector3>& points, const Vec4f color)
 {
   if (!m_Update || points.empty())
     return;
 
   unsigned int numPoints = points.size();
 
-  vtkPoints* vtkPoints = vtkPoints::New();
+  vtkSmartPointer<vtkPoints> vtkPoints = vtkSmartPointer<::vtkPoints>::New();
   vtkPoints->SetNumberOfPoints(numPoints);
 
   for (unsigned int i = 0; i < numPoints; ++i)
     vtkPoints->SetPoint(i, points[i].elems);
 
-  vtkPolyData* polyData = vtkPolyData::New();
+  vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   polyData->SetPoints(vtkPoints);
 
-  vtkPoints->Delete();
-
-  vtkCellArray* triangles = vtkCellArray::New();
+  vtkSmartPointer<vtkCellArray> triangles = vtkSmartPointer<vtkCellArray>::New();
 
   for (unsigned int i = 0; i < points.size(); i += 3)
   {
     triangles->InsertNextCell(3);
     triangles->InsertCellPoint(i);
     triangles->InsertCellPoint(i + 1);
     triangles->InsertCellPoint(i + 2);
   }
 
   polyData->SetPolys(triangles);
 
-  triangles->Delete();
-
-  vtkPolyDataNormals* polyDataNormals = vtkPolyDataNormals::New();
+  vtkSmartPointer<vtkPolyDataNormals> polyDataNormals = vtkSmartPointer<vtkPolyDataNormals>::New();
   polyDataNormals->ComputeCellNormalsOff();
   polyDataNormals->SetInput(polyData);
   polyDataNormals->SplittingOff();
 
-  vtkPolyDataMapper* polyDataMapper = vtkPolyDataMapper::New();
+  vtkSmartPointer<vtkPolyDataMapper> polyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   polyDataMapper->SetInput(polyDataNormals->GetOutput());
 
-  vtkActor* actor = vtkActor::New();
+  vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
   actor->SetMapper(polyDataMapper);
   actor->SetScale(Simulation::ScaleFactor);
 
   vtkProperty* property = actor->GetProperty();
-
   this->InitProperty(property);
-
   property->SetColor(color.x(), color.y(), color.z());
 
-  m_VtkObjects.push_back(polyData);
-  m_VtkObjects.push_back(polyDataMapper);
-  m_VtkObjects.push_back(polyDataNormals);
   m_Actors.push_back(actor);
 }
 
 void mitk::SimulationDrawTool::drawTriangles(const std::vector<Vector3>& points, const Vector3 normal, const Vec4f color)
 {
   if (!m_Update || points.empty())
     return;
 
   unsigned int numPoints = points.size();
   unsigned int numNormals = numPoints / 3;
 
-  vtkPoints* vtkPoints = vtkPoints::New();
+  vtkSmartPointer<vtkPoints> vtkPoints = vtkSmartPointer<::vtkPoints>::New();
   vtkPoints->SetNumberOfPoints(numPoints);
 
   for (unsigned int i = 0; i < numPoints; ++i)
     vtkPoints->SetPoint(i, points[i].elems);
 
-  vtkPolyData* polyData = vtkPolyData::New();
+  vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   polyData->SetPoints(vtkPoints);
 
-  vtkPoints->Delete();
-
-  vtkCellArray* triangles = vtkCellArray::New();
+  vtkSmartPointer<vtkCellArray> triangles = vtkSmartPointer<vtkCellArray>::New();
 
   for (unsigned int i = 0; i < points.size(); i += 3)
   {
     triangles->InsertNextCell(3);
     triangles->InsertCellPoint(i);
     triangles->InsertCellPoint(i + 1);
     triangles->InsertCellPoint(i + 2);
   }
 
   polyData->SetPolys(triangles);
 
-  triangles->Delete();
-
-  vtkFloatArray* normals = vtkFloatArray::New();
+  vtkSmartPointer<vtkFloatArray> normals = vtkSmartPointer<vtkFloatArray>::New();
   normals->SetNumberOfComponents(3);
   normals->SetNumberOfTuples(numNormals);
   normals->SetName("Normals");
 
   for (unsigned int i = 0; i < numNormals; ++i)
     normals->SetTuple(i, normal.elems);
 
   polyData->GetCellData()->SetNormals(normals);
 
-  normals->Delete();
-
-  vtkPolyDataMapper* polyDataMapper = vtkPolyDataMapper::New();
+  vtkSmartPointer<vtkPolyDataMapper> polyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   polyDataMapper->SetInput(polyData);
 
-  vtkActor* actor = vtkActor::New();
+  vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
   actor->SetMapper(polyDataMapper);
   actor->SetScale(Simulation::ScaleFactor);
 
   vtkProperty* property = actor->GetProperty();
-
   this->InitProperty(property);
-
   property->SetColor(color.x(), color.y(), color.z());
 
-  m_VtkObjects.push_back(polyData);
-  m_VtkObjects.push_back(polyDataMapper);
   m_Actors.push_back(actor);
 }
 
 void mitk::SimulationDrawTool::drawTriangles(const std::vector<Vector3>& points, const std::vector<Vec3i>& indices, const std::vector<Vector3>& normals, const Vec4f color)
 {
   if (!m_Update || points.empty() || indices.empty() || normals.empty())
     return;
 
   unsigned int numPoints = points.size();
 
-  vtkPoints* vtkPoints = vtkPoints::New();
+  vtkSmartPointer<vtkPoints> vtkPoints = vtkSmartPointer<::vtkPoints>::New();
   vtkPoints->SetNumberOfPoints(numPoints);
 
   for (unsigned int i = 0; i < numPoints; ++i)
     vtkPoints->SetPoint(i, points[i].elems);
 
-  vtkPolyData* polyData = vtkPolyData::New();
+  vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   polyData->SetPoints(vtkPoints);
 
-  vtkPoints->Delete();
-
-  vtkCellArray* triangles = vtkCellArray::New();
+  vtkSmartPointer<vtkCellArray> triangles = vtkSmartPointer<vtkCellArray>::New();
 
   unsigned int numIndices = indices.size();
 
   for (unsigned int i = 0; i < numIndices; ++i)
   {
     triangles->InsertNextCell(3);
     triangles->InsertCellPoint(indices[i].elems[0]);
     triangles->InsertCellPoint(indices[i].elems[1]);
     triangles->InsertCellPoint(indices[i].elems[2]);
   }
 
   polyData->SetPolys(triangles);
 
-  triangles->Delete();
-
   unsigned int numNormals = normals.size();
 
-  vtkFloatArray* vtkNormals = vtkFloatArray::New();
+  vtkSmartPointer<vtkFloatArray> vtkNormals = vtkSmartPointer<vtkFloatArray>::New();
   vtkNormals->SetNumberOfComponents(3);
   vtkNormals->SetNumberOfTuples(numNormals);
   vtkNormals->SetName("Normals");
 
   for (unsigned int i = 0; i < numNormals; ++i)
     vtkNormals->SetTuple(i, normals[i].elems);
 
   polyData->GetCellData()->SetNormals(vtkNormals);
 
-  vtkNormals->Delete();
-
-  vtkPolyDataMapper* polyDataMapper = vtkPolyDataMapper::New();
+  vtkSmartPointer<vtkPolyDataMapper> polyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   polyDataMapper->SetInput(polyData);
 
-  vtkActor* actor = vtkActor::New();
+  vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
   actor->SetMapper(polyDataMapper);
   actor->SetScale(Simulation::ScaleFactor);
 
   vtkProperty* property = actor->GetProperty();
-
   this->InitProperty(property);
-
   property->SetColor(color.x(), color.y(), color.z());
 
-  m_VtkObjects.push_back(polyData);
-  m_VtkObjects.push_back(polyDataMapper);
   m_Actors.push_back(actor);
 }
 
 void mitk::SimulationDrawTool::drawTriangles(const std::vector<Vector3>&, const std::vector<Vector3>&, const std::vector<Vec4f>&)
 {
 }
 
 void mitk::SimulationDrawTool::drawTriangleStrip(const std::vector<Vector3>&, const std::vector<Vector3>&, const Vec4f)
 {
 }
 
 void mitk::SimulationDrawTool::drawTriangleFan(const std::vector<Vector3>&, const std::vector<Vector3>&, const Vec4f)
 {
 }
 
 void mitk::SimulationDrawTool::drawFrame(const Vector3& position, const Quaternion& orientation, const Vec3f& size)
 {
   if (!m_Update)
     return;
 
   float minSize = std::min(std::min(size.x(), size.y()), size.z());
   float maxSize = std::max(std::max(size.x(), size.y()), size.z());
 
   if (maxSize > minSize * 2.0f)
   {
     if (minSize > 0.0f)
       maxSize = minSize * 2.0f;
     else
       minSize = maxSize * 0.707f;
   }
 
   const float radii[] = { minSize * 0.1f, maxSize * 0.2f };
 
   bool wireframeBackup = m_Wireframe;
   m_Wireframe = false;
 
   if (size.x() != 0.0f)
   {
     Vector3 point2 = position + orientation.rotate(Vec3f(size.x(), 0.0f, 0.0f));
     Vector3 point3 = point2 + orientation.rotate(Vec3f(radii[1], 0.0f, 0.0f));
     Vec4f red(1.0f, 0.0f, 0.0f, 1.0f);
 
     this->drawCylinder(position, point2, radii[0], red);
     this->drawCone(point2, point3, radii[1], 0.0f, red);
   }
 
   if (size.y() != 0.0f)
   {
     Vector3 point2 = position + orientation.rotate(Vec3f(0.0f, size.y(), 0.0f));
     Vector3 point3 = point2 + orientation.rotate(Vec3f(0.0f, radii[1], 0.0f));
     Vec4f green(0.0f, 1.0f, 0.0f, 1.0f);
 
     this->drawCylinder(position, point2, radii[0], green);
     this->drawCone(point2, point3, radii[1], 0.0f, green);
   }
 
   if (size.z() != 0.0f)
   {
     Vector3 point2 = position + orientation.rotate(Vec3f(0.0f, 0.0f, size.z()));
     Vector3 point3 = point2 + orientation.rotate(Vec3f(0.0f, 0.0f, radii[1]));
     Vec4f blue(0.0f, 0.0f, 1.0f, 1.0f);
 
     this->drawCylinder(position, point2, radii[0], blue);
     this->drawCone(point2, point3, radii[1], 0.0f, blue);
   }
 
   m_Wireframe = wireframeBackup;
 }
 
 void mitk::SimulationDrawTool::drawSpheres(const std::vector<Vector3>& points, const std::vector<float>& radii, const Vec4f color)
 {
   if (!m_Update || points.empty())
     return;
 
   unsigned int numSpheres = points.size();
 
   for (unsigned int i = 0; i < numSpheres; ++i)
   {
-    vtkSphereSource *sphereSource = vtkSphereSource::New();
+    vtkSmartPointer<vtkSphereSource> sphereSource = vtkSmartPointer<vtkSphereSource>::New();
     sphereSource->SetCenter(const_cast<double*>(points[i].elems));
     sphereSource->SetRadius(radii[i]);
     sphereSource->SetPhiResolution(16);
     sphereSource->SetThetaResolution(32);
     sphereSource->LatLongTessellationOn();
 
-    vtkPolyDataMapper* polyDataMapper = vtkPolyDataMapper::New();
-    polyDataMapper->SetInput(sphereSource->GetOutput());
+    vtkSmartPointer<vtkPolyDataMapper> polyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+    polyDataMapper->SetInputConnection(sphereSource->GetOutputPort());
 
-    vtkActor* actor = vtkActor::New();
+    vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
     actor->SetMapper(polyDataMapper);
     actor->SetScale(Simulation::ScaleFactor);
 
     vtkProperty* property = actor->GetProperty();
-
     this->InitProperty(property);
-
     property->SetColor(color.x(), color.y(), color.z());
 
-    m_VtkObjects.push_back(sphereSource);
-    m_VtkObjects.push_back(polyDataMapper);
     m_Actors.push_back(actor);
   }
 }
 
 void mitk::SimulationDrawTool::drawSpheres(const std::vector<Vector3>& points, float radius, const Vec4f color)
 {
   if (!m_Update || points.empty())
     return;
 
   unsigned int numPoints = points.size();
   std::vector<float> radii(numPoints, radius);
 
   this->drawSpheres(points, radii, color);
 }
 
 void mitk::SimulationDrawTool::drawCone(const Vector3& point1, const Vector3& point2, float radius1, float radius2, const Vec4f color, int subdivisions)
 {
   if (!m_Update)
     return;
 
-  vtkPoints* points = vtkPoints::New();
+  vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   points->SetNumberOfPoints(2);
   points->SetPoint(0, point1.elems);
   points->SetPoint(1, point2.elems);
 
-  vtkCellArray* line = vtkCellArray::New();
+  vtkSmartPointer<vtkCellArray> line = vtkSmartPointer<vtkCellArray>::New();
   line->InsertNextCell(2);
   line->InsertCellPoint(0);
   line->InsertCellPoint(1);
 
-  vtkPolyData* polyData = vtkPolyData::New();
+  vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   polyData->SetPoints(points);
   polyData->SetLines(line);
 
-  points->Delete();
-  line->Delete();
-
   const char* radiiName = "Radii";
 
-  vtkFloatArray* radii = vtkFloatArray::New();
+  vtkSmartPointer<vtkFloatArray> radii = vtkSmartPointer<vtkFloatArray>::New();
   radii->SetName(radiiName);
   radii->SetNumberOfTuples(2);
   radii->SetTuple1(0, radius1);
   radii->SetTuple1(1, radius2);
 
   vtkPointData* pointData = polyData->GetPointData();
   pointData->AddArray(radii);
   pointData->SetActiveScalars(radiiName);
 
-  radii->Delete();
-
-  vtkTubeFilter* tubeFilter = vtkTubeFilter::New();
+  vtkSmartPointer<vtkTubeFilter> tubeFilter = vtkSmartPointer<vtkTubeFilter>::New();
   tubeFilter->SetInput(polyData);
   tubeFilter->CappingOn();
   tubeFilter->SetNumberOfSides(subdivisions);
   tubeFilter->SetVaryRadiusToVaryRadiusByAbsoluteScalar();
 
-  vtkPolyDataMapper* polyDataMapper = vtkPolyDataMapper::New();
-  polyDataMapper->SetInput(tubeFilter->GetOutput());
+  vtkSmartPointer<vtkPolyDataMapper> polyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+  polyDataMapper->SetInputConnection(tubeFilter->GetOutputPort());
   polyDataMapper->ScalarVisibilityOff();
 
-  vtkActor* actor = vtkActor::New();
+  vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
   actor->SetMapper(polyDataMapper);
   actor->SetScale(Simulation::ScaleFactor);
 
   vtkProperty* property = actor->GetProperty();
-
   this->InitProperty(property);
-
   property->SetColor(color.x(), color.y(), color.z());
 
-  m_VtkObjects.push_back(polyData);
-  m_VtkObjects.push_back(tubeFilter);
-  m_VtkObjects.push_back(polyDataMapper);
   m_Actors.push_back(actor);
 }
 
 void mitk::SimulationDrawTool::drawCube(const float&, const Vec4f&, const int&)
 {
 }
 
 void mitk::SimulationDrawTool::drawCylinder(const Vector3& point1, const Vector3& point2, float radius, const Vec4f color, int subdivisions)
 {
   if (!m_Update)
     return;
 
   this->drawCone(point1, point2, radius, radius, color, subdivisions);
 }
 
 void mitk::SimulationDrawTool::drawCapsule(const Vector3&, const Vector3&, float, const Vec4f, int)
 {
 }
 
 void mitk::SimulationDrawTool::drawArrow(const Vector3& point1, const Vector3& point2, float radius, const Vec4f color, int subdivisions)
 {
   if (!m_Update)
     return;
 
   Vector3 point3 = point1 * 0.2f + point2 * 0.8f;
 
   this->drawCylinder(point1, point3, radius, color, subdivisions);
   this->drawCone(point3, point2, radius * 2.5f, 0.0f, color, subdivisions);
 }
 
 void mitk::SimulationDrawTool::drawPlus(const float& edgeRadius, const Vec4f& color, const int& subdivisions)
 {
   if (!m_Update)
     return;
 
   this->drawCylinder(Vector3(-1.0, 0.0, 0.0), Vector3(1.0, 0.0, 0.0), edgeRadius, color, subdivisions);
   this->drawCylinder(Vector3(0.0, -1.0, 0.0), Vector3(0.0, 1.0, 0.0), edgeRadius, color, subdivisions);
   this->drawCylinder(Vector3(0.0, 0.0, -1.0), Vector3(0.0, 0.0, 1.0), edgeRadius, color, subdivisions);
 }
 
 void mitk::SimulationDrawTool::drawPoint(const Vector3&, const Vec4f&)
 {
 }
 
 void mitk::SimulationDrawTool::drawPoint(const Vector3&, const Vector3&, const Vec4f&)
 {
 }
 
 void mitk::SimulationDrawTool::drawTriangle(const Vector3&, const Vector3&, const Vector3&, const Vector3&)
 {
 }
 
 void mitk::SimulationDrawTool::drawTriangle(const Vector3&, const Vector3&, const Vector3&, const Vector3&, const Vec4f&)
 {
 }
 
 void mitk::SimulationDrawTool::drawTriangle(const Vector3&, const Vector3&, const Vector3&, const Vector3&, const Vec4f&, const Vec4f&, const Vec4f&)
 {
 }
 
 void mitk::SimulationDrawTool::drawSphere(const Vector3&, float)
 {
 }
 
 void mitk::SimulationDrawTool::pushMatrix()
 {
 }
 
 void mitk::SimulationDrawTool::popMatrix()
 {
 }
 
 void mitk::SimulationDrawTool::multMatrix(float*)
 {
 }
 
 void mitk::SimulationDrawTool::scale(float)
 {
 }
 
 void mitk::SimulationDrawTool::setMaterial(const Vec4f&, std::string)
 {
 }
 
 void mitk::SimulationDrawTool::resetMaterial(const Vec4f&, std::string)
 {
 }
 
 void mitk::SimulationDrawTool::setPolygonMode(int mode, bool wireframe)
 {
   if (!m_Update)
     return;
 
   m_PolygonMode = mode;
   m_Wireframe = wireframe;
 }
 
 void mitk::SimulationDrawTool::setLightingEnabled(bool)
 {
 }
 
 void mitk::SimulationDrawTool::writeOverlayText(int, int, unsigned int, const Vec4f&, const char*)
 {
 }
diff --git a/Modules/Simulation/mitkSimulationDrawTool.h b/Modules/Simulation/mitkSimulationDrawTool.h
index 519b39c82b..948638a254 100644
--- a/Modules/Simulation/mitkSimulationDrawTool.h
+++ b/Modules/Simulation/mitkSimulationDrawTool.h
@@ -1,109 +1,107 @@
 /*===================================================================
 
 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 mitkSimulationDrawTool_h
 #define mitkSimulationDrawTool_h
 
 #include <SimulationExports.h>
 #include <sofa/core/visual/DrawTool.h>
+#include <vtkActor.h>
+#include <vtkSmartPointer.h>
 
-class vtkActor;
-class vtkObjectBase;
 class vtkProperty;
 
 namespace mitk
 {
   /** \brief Utility class used by SOFA classes to draw objects other than visual models.
     *
     * Implements the <tt>sofa::core::visual::DrawTool</tt> interface and replaces the default SOFA OpenGL implementation <tt>sofa::core::visual::DrawToolGL</tt>.
     * All draw methods create a VTK actor and append it to an internal list which can be queried by calling GetActors() to finally draw them.
     * In contrary to the original concept of <tt>DrawToolGL</tt>, which is set once during initialization of SOFA applications, every mitk::Simulation has its own exclusive copy of mitk::SimulationDrawTool.
     * Since SOFA can handle only a single <tt>DrawTool</tt> at once it must be ensured that the correct mitk::SimulationDrawTool is set when switching the active simulation.
     *
     * Each draw method checks if it is necessary to generate a new up-to-date VTK actor, i.e. after a simulation step, or if it is sufficient to use the already generated one.
     * This decision is controlled through the methods Reset() and DisableUpdate().
     * The former method must be called right before a simulation step and mitk::SimulationMapper3D calls the latter method during rendering to disable unnecessary updates until the next simulation step.
     */
   class Simulation_EXPORT SimulationDrawTool : public sofa::core::visual::DrawTool
   {
   public:
     SimulationDrawTool();
     ~SimulationDrawTool();
 
     /** \brief Disables creation of new VTK actors when calling draw methods.
       */
     void DisableUpdate();
 
     /** \brief Returns current list of VTK actors which were generated by draw methods since the last reset.
       *
       * \note Do not delete the VTK actors returned by this method.
       */
-    std::vector<vtkActor*> GetActors() const;
+    std::vector<vtkSmartPointer<vtkActor> > GetActors() const;
 
     /** \brief Clears internal lists of current VTK objects and enables creation of new VTK actors when calling draw methods.
       */
     void Reset();
 
     void drawPoints(const std::vector<Vector3>& points, float pointSize, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
     void drawLines(const std::vector<Vector3>& points, float lineWidth, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
     void drawLines(const std::vector<Vector3>& points, const std::vector<Vec2i>& indices, float lineWidth, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
     void drawTriangles(const std::vector<Vector3>& points, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
     void drawTriangles(const std::vector<Vector3>& points, const Vector3 normal, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
     void drawTriangles(const std::vector<Vector3>& points, const std::vector<Vec3i>& indices, const std::vector<Vector3>& normals, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
     void drawTriangles(const std::vector<Vector3>& points, const std::vector<Vector3>& normals, const std::vector<Vec4f>& colors);
     void drawTriangleStrip(const std::vector<Vector3>& points, const std::vector<Vector3>& normals, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
     void drawTriangleFan(const std::vector<Vector3>& points, const std::vector<Vector3>& normals, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
     void drawFrame(const Vector3& position, const Quaternion& orientation, const Vec3f& size);
     void drawSpheres(const std::vector<Vector3>& points, const std::vector<float>& radii, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
     void drawSpheres(const std::vector<Vector3>& points, float radius, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
     void drawCone(const Vector3& point1, const Vector3& point2, float radius1, float radius2, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), int subdivisions = 16);
     void drawCube(const float& edgeRadius, const Vec4f& color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), const int& subdivisions = 16);
     void drawCylinder(const Vector3& point1, const Vector3& point2, float radius, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), int subdivisions = 16);
     void drawCapsule(const Vector3& point1, const Vector3& point2, float radius, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), int subdivisions = 16);
     void drawArrow(const Vector3& point1, const Vector3& point2, float radius, const Vec4f color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), int subdivisions = 16);
     void drawPlus(const float& edgeRadius, const Vec4f& color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f), const int& subdivisions = 16);
     void drawPoint(const Vector3& position, const Vec4f& color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
     void drawPoint(const Vector3& position, const Vector3& normal, const Vec4f& color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
     void drawTriangle(const Vector3& point1, const Vector3& point2, const Vector3& point3, const Vector3& normal);
     void drawTriangle(const Vector3& point1, const Vector3& point2, const Vector3& point3, const Vector3& normal, const Vec4f& color = Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
     void drawTriangle(const Vector3& point1, const Vector3& point2, const Vector3& point3, const Vector3& normal, const Vec4f& color1, const Vec4f& color2, const Vec4f& color3);
     void drawSphere(const Vector3& position, float radius);
     void pushMatrix();
     void popMatrix();
     void multMatrix(float* matrix);
     void scale(float factor);
     void setMaterial(const Vec4f& color, std::string name = "");
     void resetMaterial(const Vec4f& color, std::string name = "");
     void setPolygonMode(int mode, bool wireframe);
     void setLightingEnabled(bool isEnabled);
     void writeOverlayText(int x, int y, unsigned int fontSize, const Vec4f& color, const char* text);
 
   private:
     SimulationDrawTool(const SimulationDrawTool&);
     SimulationDrawTool& operator=(const SimulationDrawTool&);
 
-    void DeleteVtkObjects();
     void InitProperty(vtkProperty* property) const;
 
-    std::vector<vtkObjectBase*> m_VtkObjects;
-    std::vector<vtkActor*> m_Actors;
+    std::vector<vtkSmartPointer<vtkActor> > m_Actors;
     int m_PolygonMode;
     bool m_Wireframe;
     bool m_Update;
   };
 }
 
 #endif
diff --git a/Modules/Simulation/mitkSimulationMapper3D.cpp b/Modules/Simulation/mitkSimulationMapper3D.cpp
index fc65b28ae7..8b7a5c64f0 100644
--- a/Modules/Simulation/mitkSimulationMapper3D.cpp
+++ b/Modules/Simulation/mitkSimulationMapper3D.cpp
@@ -1,242 +1,242 @@
 /*===================================================================
 
 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 "mitkSimulation.h"
 #include "mitkSimulationMapper3D.h"
 #include "mitkSimulationModel.h"
 #include "mitkSimulationPropAssemblyVisitor.h"
 #include <sofa/component/visualmodel/VisualStyle.h>
 #include <sofa/core/visual/VisualParams.h>
 
 mitk::SimulationMapper3D::LocalStorage::LocalStorage()
   : m_VtkProp(vtkSmartPointer<vtkPropAssembly>::New())
 {
 }
 
 mitk::SimulationMapper3D::LocalStorage::~LocalStorage()
 {
 }
 
 void mitk::SimulationMapper3D::SetDefaultProperties(DataNode* node, BaseRenderer* renderer, bool overwrite)
 {
   if (node != NULL)
   {
     mitk::Simulation* simulation = dynamic_cast<mitk::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()), renderer, overwrite);
     }
 
     Superclass::SetDefaultProperties(node, renderer, overwrite);
   }
 }
 
 mitk::SimulationMapper3D::SimulationMapper3D()
 {
 }
 
 mitk::SimulationMapper3D::~SimulationMapper3D()
 {
 }
 
 void mitk::SimulationMapper3D::ApplyProperties(vtkActor* actor, mitk::BaseRenderer* renderer)
 {
   if (actor == NULL)
   {
     mitk::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);
 
     mitk::Simulation* simulation = static_cast<mitk::Simulation*>(this->GetData());
     sofa::component::visualmodel::VisualStyle::SPtr visualStyle;
     simulation->GetRootNode()->get(visualStyle);
 
     bool update = false;
 
     sofa::core::visual::DisplayFlags* displayFlags = visualStyle->displayFlags.beginEdit();
 
     if (showBehaviorModels != displayFlags->getShowBehaviorModels())
     {
       displayFlags->setShowBehaviorModels(showBehaviorModels);
       update = true;
     }
 
     if (showForceFields != displayFlags->getShowForceFields())
     {
       displayFlags->setShowForceFields(showForceFields);
       update = true;
     }
 
     if (showInteractionForceFields != displayFlags->getShowInteractionForceFields())
     {
       displayFlags->setShowInteractionForceFields(showInteractionForceFields);
       update = true;
     }
 
     if (showBoundingCollisionModels != displayFlags->getShowBoundingCollisionModels())
     {
       displayFlags->setShowBoundingCollisionModels(showBoundingCollisionModels);
       update = true;
     }
 
     if (showCollisionModels != displayFlags->getShowCollisionModels())
     {
       displayFlags->setShowCollisionModels(showCollisionModels);
       update = true;
     }
 
     if (showMechanicalMappings != displayFlags->getShowMechanicalMappings())
     {
       displayFlags->setShowMechanicalMappings(showMechanicalMappings);
       update = true;
     }
 
     if (showMappings != displayFlags->getShowMappings())
     {
       displayFlags->setShowMappings(showMappings);
       update = true;
     }
 
     displayFlags->setShowNormals(showNormals);
 
     if (showWireFrame != displayFlags->getShowWireFrame())
     {
       displayFlags->setShowWireFrame(showWireFrame);
       update = true;
     }
 
     displayFlags->setShowVisualModels(showVisualModels);
 
     visualStyle->displayFlags.endEdit();
 
     if (update)
       simulation->GetDrawTool()->Reset();
   }
 }
 
 void mitk::SimulationMapper3D::GenerateDataForRenderer(mitk::BaseRenderer* renderer)
 {
   mitk::Simulation* simulation = dynamic_cast<mitk::Simulation*>(this->GetData());
 
   if (sofa::simulation::getSimulation() == NULL)
   {
     if (simulation != NULL)
     {
       simulation->SetAsActiveSimulation();
       simulation->GetDrawTool()->Reset();
     }
     else
     {
       return;
     }
   }
 
   LocalStorage* localStorage = m_LocalStorageHandler.GetLocalStorage(renderer);
   localStorage->m_VtkProp = vtkSmartPointer<vtkPropAssembly>::New();
 
   if (simulation != NULL)
   {
     sofa::simulation::Simulation::SPtr sofaSimulation = simulation->GetSimulation();
     sofa::simulation::Node::SPtr rootNode = simulation->GetRootNode();
     sofa::core::visual::VisualParams* vParams = sofa::core::visual::VisualParams::defaultInstance();
     SimulationDrawTool* drawTool = simulation->GetDrawTool();
 
     sofa::simulation::Simulation* backupSimulation = NULL;
     sofa::core::visual::DrawTool* backupDrawTool = NULL;
 
     if (sofa::simulation::getSimulation() != sofaSimulation.get())
     {
       backupSimulation = sofa::simulation::getSimulation();
       backupDrawTool = vParams->drawTool();
 
       sofa::simulation::setSimulation(sofaSimulation.get());
       vParams->drawTool() = drawTool;
     }
 
     this->ApplyProperties(NULL, renderer);
 
     sofaSimulation->updateVisual(rootNode.get());
     sofaSimulation->draw(vParams, rootNode.get());
     drawTool->DisableUpdate();
 
     SimulationPropAssemblyVisitor propAssemblyVisitor(localStorage->m_VtkProp);
     rootNode->executeVisitor(&propAssemblyVisitor);
 
-    std::vector<vtkActor*> actors = drawTool->GetActors();
+    std::vector<vtkSmartPointer<vtkActor> > actors = drawTool->GetActors();
 
-    for (std::vector<vtkActor*>::const_iterator actor = actors.begin(); actor != actors.end(); ++actor)
+    for (std::vector<vtkSmartPointer<vtkActor> >::const_iterator actor = actors.begin(); actor != actors.end(); ++actor)
       localStorage->m_VtkProp->AddPart(*actor);
 
     if (backupSimulation != NULL)
     {
       sofa::simulation::setSimulation(backupSimulation);
       vParams->drawTool() = backupDrawTool;
     }
   }
 }
 
 vtkProp* mitk::SimulationMapper3D::GetVtkProp(mitk::BaseRenderer* renderer)
 {
   return m_LocalStorageHandler.GetLocalStorage(renderer)->m_VtkProp;
 }
diff --git a/Modules/Simulation/mitkSimulationModel.cpp b/Modules/Simulation/mitkSimulationModel.cpp
index e3dc34af7c..bd9c4a816d 100644
--- a/Modules/Simulation/mitkSimulationModel.cpp
+++ b/Modules/Simulation/mitkSimulationModel.cpp
@@ -1,329 +1,300 @@
 /*===================================================================
 
 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 "mitkSimulation.h"
 #include "mitkSimulationModel.h"
 #include <sofa/core/visual/DisplayFlags.h>
 #include <sofa/core/visual/VisualParams.h>
-#include <vtkActor.h>
 #include <vtkCellArray.h>
 #include <vtkFloatArray.h>
 #include <vtkImageReader2.h>
 #include <vtkImageReader2Factory.h>
 #include <vtkPointData.h>
 #include <vtkPolyData.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkProperty.h>
-#include <vtkSmartPointer.h>
-#include <vtkTexture.h>
 
 mitk::SimulationModel::SimulationModel()
   : m_LastTime(-1.0),
     m_LastShowNormals(false),
     m_LastShowVisualModels(true),
     m_LastShowWireFrame(false)
 {
 }
 
 mitk::SimulationModel::~SimulationModel()
 {
-  this->DeleteVtkTextures();
-  this->DeleteVtkObjects();
-}
-
-void mitk::SimulationModel::DeleteVtkObjects()
-{
-  for (std::vector<vtkObjectBase*>::const_iterator object = m_VtkObjects.begin(); object != m_VtkObjects.end(); ++object)
-    (*object)->Delete();
-
-  m_VtkObjects.clear();
-
-  for (std::vector<vtkActor*>::const_iterator actor = m_Actors.begin(); actor != m_Actors.end(); ++actor)
-    (*actor)->Delete();
-
   m_Actors.clear();
-}
-
-void mitk::SimulationModel::DeleteVtkTextures()
-{
-  for (std::map<unsigned int, vtkTexture*>::const_iterator texture = m_Textures.begin(); texture != m_Textures.end(); ++texture)
-    texture->second->Delete();
-
   m_Textures.clear();
 }
 
 void mitk::SimulationModel::DrawGroup(int ig, const sofa::core::visual::VisualParams* vparams, bool transparent)
 {
   const sofa::defaulttype::ResizableExtVector<Triangle>& triangles = this->getTriangles();
   const sofa::defaulttype::ResizableExtVector<Quad>& quads = this->getQuads();
   FaceGroup g;
 
   if (ig < 0)
   {
     g.materialId = -1;
     g.tri0 = 0;
     g.nbt = triangles.size();
     g.quad0 = 0;
     g.nbq = quads.size();
   }
   else
   {
     g = groups.getValue()[ig];
   }
 
   const sofa::defaulttype::ResizableExtVector<Coord>& vertices = this->getVertices();
   unsigned int numVertices = vertices.size();
 
   vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
   points->SetNumberOfPoints(numVertices);
 
   for (unsigned int i = 0; i < numVertices; ++i)
     points->SetPoint(i, vertices[i].elems);
 
-  vtkPolyData* polyData = vtkPolyData::New();
+  vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   polyData->SetPoints(points);
 
   vtkSmartPointer<vtkCellArray> polys = vtkSmartPointer<vtkCellArray>::New();
 
   int numTriangles = g.tri0 + g.nbt;
   int numQuads = g.quad0 + g.nbq;
 
   for (int i = g.tri0; i < numTriangles; ++i)
   {
     polys->InsertNextCell(3);
     polys->InsertCellPoint(triangles[i].elems[0]);
     polys->InsertCellPoint(triangles[i].elems[1]);
     polys->InsertCellPoint(triangles[i].elems[2]);
   }
 
   for (int i = g.quad0; i < numQuads; ++i)
   {
     polys->InsertNextCell(4);
     polys->InsertCellPoint(quads[i].elems[0]);
     polys->InsertCellPoint(quads[i].elems[1]);
     polys->InsertCellPoint(quads[i].elems[2]);
     polys->InsertCellPoint(quads[i].elems[3]);
   }
 
   polyData->SetPolys(polys);
 
   const sofa::defaulttype::ResizableExtVector<Coord>& normals = this->getVnormals();
   unsigned int numNormals = normals.size();
 
   vtkSmartPointer<vtkFloatArray> vtkNormals = vtkSmartPointer<vtkFloatArray>::New();
   vtkNormals->SetNumberOfComponents(3);
   vtkNormals->SetNumberOfTuples(numNormals);
 
   for (unsigned int i = 0; i < numNormals; ++i)
     vtkNormals->SetTuple(i, normals[i].elems);
 
   polyData->GetPointData()->SetNormals(vtkNormals);
 
   sofa::core::loader::Material m = g.materialId >= 0
     ? materials.getValue()[g.materialId]
     : material.getValue();
 
   if (m.useTexture && m.activated)
   {
     const sofa::defaulttype::ResizableExtVector<TexCoord>& texCoords = this->getVtexcoords();
     unsigned int numTexCoords = texCoords.size();
 
     vtkSmartPointer<vtkFloatArray> vtkTexCoords = vtkSmartPointer<vtkFloatArray>::New();
     vtkTexCoords->SetNumberOfComponents(2);
     vtkTexCoords->SetNumberOfTuples(numTexCoords);
 
     for (unsigned int i = 0; i < numTexCoords; ++i)
       vtkTexCoords->SetTuple(i, texCoords[i].elems);
 
     polyData->GetPointData()->SetTCoords(vtkTexCoords);
   }
 
-  vtkPolyDataMapper* polyDataMapper = vtkPolyDataMapper::New();
+  vtkSmartPointer<vtkPolyDataMapper> polyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   polyDataMapper->SetInput(polyData);
 
-  vtkActor* actor = vtkActor::New();
+  vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
   actor->SetMapper(polyDataMapper);
   actor->SetScale(Simulation::ScaleFactor);
 
   if (m.useTexture && m.activated)
     actor->SetTexture(m_Textures[g.materialId]);
 
   sofa::defaulttype::Vec4f ambient = !m.useAmbient
     ? sofa::defaulttype::Vec4f()
     : m.ambient;
 
   sofa::defaulttype::Vec4f diffuse = !m.useDiffuse
     ? sofa::defaulttype::Vec4f()
     : m.diffuse;
 
   sofa::defaulttype::Vec4f specular = !m.useSpecular
     ? sofa::defaulttype::Vec4f()
     : m.specular;
 
   float shininess = m.useShininess
     ? m.shininess
     : 45.0f;
 
   if (shininess == 0.0f)
   {
     specular.clear();
     shininess = 1.0f;
   }
 
   vtkProperty* property = actor->GetProperty();
 
   property->SetAmbientColor(ambient.x(), ambient.y(), ambient.z());
   property->SetDiffuseColor(diffuse.x(), diffuse.y(), diffuse.z());
   property->SetSpecular(1.0);
   property->SetSpecularColor(specular.x(), specular.y(), specular.z());
   property->SetSpecularPower(shininess);
 
   if (vparams->displayFlags().getShowWireFrame())
     property->SetRepresentationToWireframe();
 
-  m_VtkObjects.push_back(polyData);
-  m_VtkObjects.push_back(polyDataMapper);
   m_Actors.push_back(actor);
 
   if (!m_LastShowNormals)
    return;
 
   points = vtkSmartPointer<vtkPoints>::New();
   points->SetNumberOfPoints(numVertices * 2);
 
   vtkSmartPointer<vtkCellArray> lines = vtkSmartPointer<vtkCellArray>::New();
 
   for (unsigned int i = 0; i < numVertices; ++i)
   {
     unsigned int j = 2 * i;
     unsigned int k = j + 1;
 
     points->SetPoint(j, vertices[i].elems);
     points->SetPoint(k, (vertices[i] + normals[i]).elems);
 
     lines->InsertNextCell(2);
     lines->InsertCellPoint(j);
     lines->InsertCellPoint(k);
   }
 
-  polyData = vtkPolyData::New();
+  polyData = vtkSmartPointer<vtkPolyData>::New();
   polyData->SetPoints(points);
   polyData->SetLines(lines);
 
-  polyDataMapper = vtkPolyDataMapper::New();
+  polyDataMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
   polyDataMapper->SetInput(polyData);
 
-  actor = vtkActor::New();
+  actor = vtkSmartPointer<vtkActor>::New();
   actor->SetMapper(polyDataMapper);
   actor->SetScale(Simulation::ScaleFactor);
 
-  m_VtkObjects.push_back(polyData);
-  m_VtkObjects.push_back(polyDataMapper);
   m_Actors.push_back(actor);
 }
 
-std::vector<vtkActor*> mitk::SimulationModel::GetActors() const
+std::vector<vtkSmartPointer<vtkActor> > mitk::SimulationModel::GetActors() const
 {
   return m_Actors;
 }
 
 void mitk::SimulationModel::internalDraw(const sofa::core::visual::VisualParams* vparams, bool transparent)
 {
   double time = this->getContext()->getTime();
 
   const sofa::core::visual::DisplayFlags& displayFlags = vparams->displayFlags();
   bool showNormals = displayFlags.getShowNormals();
   bool showVisualModels = displayFlags.getShowVisualModels();
   bool showWireFrame = displayFlags.getShowWireFrame();
 
   if (time == m_LastTime && showNormals == m_LastShowNormals && showVisualModels == m_LastShowVisualModels && showWireFrame == m_LastShowWireFrame)
     return;
 
   m_LastTime = time;
   m_LastShowNormals = showNormals;
   m_LastShowVisualModels = showVisualModels;
   m_LastShowWireFrame = showWireFrame;
 
   if (transparent)
     return;
 
-  this->DeleteVtkObjects();
+  m_Actors.clear();
 
   if (!vparams->displayFlags().getShowVisualModels())
     return;
 
   sofa::helper::ReadAccessor<sofa::Data<sofa::helper::vector<FaceGroup> > > groups = this->groups;
 
   if (groups.empty())
   {
     this->DrawGroup(-1, vparams, transparent);
   }
   else
   {
     for (unsigned int i = 0; i < groups.size(); ++i)
       this->DrawGroup(i, vparams, transparent);
   }
 }
 
 bool mitk::SimulationModel::loadTexture(const std::string& filename)
 {
   return false;
 }
 
 bool mitk::SimulationModel::loadTextures()
 {
-  this->DeleteVtkTextures();
+  m_Textures.clear();
 
   std::vector<unsigned int> activatedTextures;
 
   const sofa::helper::vector<sofa::core::loader::Material>& materials = this->materials.getValue();
   unsigned int numMaterials = materials.size();
 
   for (unsigned int i = 0; i < numMaterials; ++i)
   {
     const sofa::core::loader::Material& material = materials[i];
 
     if (material.useTexture && material.activated)
       activatedTextures.push_back(i);
   }
 
   unsigned int numActivatedTextures = activatedTextures.size();
 
   for (unsigned int i = 0; i < numActivatedTextures; ++i)
   {
     std::string textureFilename = materials[activatedTextures[i]].textureFilename;
 
     if (!sofa::helper::system::DataRepository.findFile(textureFilename))
       return false;
 
-    vtkImageReader2* imageReader = vtkImageReader2Factory::CreateImageReader2(textureFilename.c_str());
+    vtkSmartPointer<vtkImageReader2> imageReader;
+    imageReader.TakeReference(vtkImageReader2Factory::CreateImageReader2(textureFilename.c_str()));
 
     if (imageReader == NULL)
       return false;
 
     imageReader->SetFileName(textureFilename.c_str());
 
-    vtkTexture* texture = vtkTexture::New();
+    vtkSmartPointer<vtkTexture> texture = vtkSmartPointer<vtkTexture>::New();
     texture->SetInput(imageReader->GetOutputDataObject(0));
     texture->InterpolateOn();
 
-    imageReader->Delete();
-
     m_Textures.insert(std::make_pair(activatedTextures[i], texture));
   }
 
   return true;
 }
diff --git a/Modules/Simulation/mitkSimulationModel.h b/Modules/Simulation/mitkSimulationModel.h
index b2a06fe9e1..e252966d3c 100644
--- a/Modules/Simulation/mitkSimulationModel.h
+++ b/Modules/Simulation/mitkSimulationModel.h
@@ -1,64 +1,60 @@
 /*===================================================================
 
 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 mitkSimulationModel_h
 #define mitkSimulationModel_h
 
 #include <SimulationExports.h>
 #include <sofa/component/visualmodel/VisualModelImpl.h>
-
-class vtkActor;
-class vtkObjectBase;
-class vtkTexture;
+#include <vtkActor.h>
+#include <vtkSmartPointer.h>
+#include <vtkTexture.h>
 
 namespace mitk
 {
   class Simulation_EXPORT SimulationModel : public sofa::component::visualmodel::VisualModelImpl
   {
   public:
     SOFA_CLASS(SimulationModel, sofa::component::visualmodel::VisualModelImpl);
 
-    std::vector<vtkActor*> GetActors() const;
+    std::vector<vtkSmartPointer<vtkActor> > GetActors() const;
 
     bool loadTexture(const std::string& filename);
     bool loadTextures();
 
   protected:
     void internalDraw(const sofa::core::visual::VisualParams* vparams, bool transparent);
 
   private:
     SimulationModel();
     ~SimulationModel();
 
     SimulationModel(const MyType&);
     MyType& operator=(const MyType&);
 
-    void DeleteVtkObjects();
-    void DeleteVtkTextures();
     void DrawGroup(int ig, const sofa::core::visual::VisualParams* vparams, bool transparent);
 
-    std::vector<vtkObjectBase*> m_VtkObjects;
-    std::vector<vtkActor*> m_Actors;
-    std::map<unsigned int, vtkTexture*> m_Textures;
+    std::vector<vtkSmartPointer<vtkActor> > m_Actors;
+    std::map<unsigned int, vtkSmartPointer<vtkTexture> > m_Textures;
 
     double m_LastTime;
     bool m_LastShowNormals;
     bool m_LastShowVisualModels;
     bool m_LastShowWireFrame;
   };
 }
 
 #endif
diff --git a/Modules/Simulation/mitkSimulationPropAssemblyVisitor.cpp b/Modules/Simulation/mitkSimulationPropAssemblyVisitor.cpp
index ac546b6e11..60f9917385 100644
--- a/Modules/Simulation/mitkSimulationPropAssemblyVisitor.cpp
+++ b/Modules/Simulation/mitkSimulationPropAssemblyVisitor.cpp
@@ -1,51 +1,51 @@
 /*===================================================================
 
 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 "mitkSimulationPropAssemblyVisitor.h"
 #include "mitkSimulationModel.h"
 #include <vtkActor.h>
 #include <vtkPropAssembly.h>
 
 mitk::SimulationPropAssemblyVisitor::SimulationPropAssemblyVisitor(vtkPropAssembly* propAssembly, const sofa::core::ExecParams* params)
   : Visitor(params),
     m_PropAssembly(propAssembly)
 {
 }
 
 mitk::SimulationPropAssemblyVisitor::~SimulationPropAssemblyVisitor()
 {
 }
 
 sofa::simulation::Visitor::Result mitk::SimulationPropAssemblyVisitor::processNodeTopDown(sofa::simulation::Node* node)
 {
   typedef sofa::simulation::Node::Sequence<sofa::core::visual::VisualModel>::const_iterator VisualModelIterator;
   VisualModelIterator end = node->visualModel.end();
 
   for (VisualModelIterator visualModel = node->visualModel.begin(); visualModel != end; ++visualModel)
   {
     SimulationModel* simulationModel = dynamic_cast<SimulationModel*>(*visualModel);
 
     if (simulationModel != NULL)
     {
-      std::vector<vtkActor*> actors = simulationModel->GetActors();
+      std::vector<vtkSmartPointer<vtkActor> > actors = simulationModel->GetActors();
 
-      for (std::vector<vtkActor*>::const_iterator actor = actors.begin(); actor != actors.end(); ++actor)
+      for (std::vector<vtkSmartPointer<vtkActor> >::const_iterator actor = actors.begin(); actor != actors.end(); ++actor)
         m_PropAssembly->AddPart(*actor);
     }
   }
 
   return RESULT_CONTINUE;
 }