diff --git a/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.cpp b/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.cpp
index 66af171c05..59e72c801c 100644
--- a/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.cpp
+++ b/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.cpp
@@ -1,396 +1,396 @@
 /*===================================================================
 
 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 "mitkContourModelSetGLMapper2D.h"
 
 #include "mitkColorProperty.h"
 #include "mitkContourModelSet.h"
 #include "mitkPlaneGeometry.h"
 #include "mitkProperties.h"
 #include <vtkLinearTransform.h>
 
 #include "mitkGL.h"
 
 mitk::ContourModelSetGLMapper2D::ContourModelSetGLMapper2D()
 {
 }
 
 mitk::ContourModelSetGLMapper2D::~ContourModelSetGLMapper2D()
 {
 }
 
 void mitk::ContourModelSetGLMapper2D::Paint(mitk::BaseRenderer *renderer)
 {
     BaseLocalStorage *ls = m_LSH.GetLocalStorage(renderer);
 
     mitk::DataNode *dataNode = this->GetDataNode();
     bool visible = true;
     dataNode->GetVisibility(visible, nullptr);
 
     if (!visible)
         return;
 
     mitk::ContourModelSet *input = this->GetInput();
 
     auto centerOfViewPointZ = renderer->GetCurrentWorldPlaneGeometry()->GetCenter()[2];
     mitk::ContourModelSet::ContourModelSetIterator it = input->Begin();
 
     mitk::ContourModelSet::ContourModelSetIterator end = input->End();
 
     while (it != end)
     {
         //we have the assumption that each contour model vertex has the same z coordinate
         auto currentZValue = (*it)->GetVertexAt(0)->Coordinates[2];
         double acceptedDeviationInMM = 5.0;
         //only draw contour if it is visible
         if (currentZValue - acceptedDeviationInMM < centerOfViewPointZ && currentZValue + acceptedDeviationInMM > centerOfViewPointZ){
             this->DrawContour(it->GetPointer(), renderer);
         }
         ++it;
     }
 
     if (input->GetSize() < 1)
         return;
 
     ls->UpdateGenerateDataTime();
 }
 
 mitk::ContourModelSet *mitk::ContourModelSetGLMapper2D::GetInput(void)
 {
   return const_cast<mitk::ContourModelSet *>(static_cast<const mitk::ContourModelSet *>(GetDataNode()->GetData()));
 }
 
 void mitk::ContourModelSetGLMapper2D::InternalDrawContour(mitk::ContourModel *renderingContour,
                                                           mitk::BaseRenderer *renderer)
 {
   if (!renderingContour)
     return;
 
   mitk::DataNode *dataNode = this->GetDataNode();
 
   renderingContour->UpdateOutputInformation();
 
   unsigned int timestep = renderer->GetTimeStep();
 
   if (!renderingContour->IsEmptyTimeStep(timestep))
   {
     // apply color and opacity read from the PropertyList
     ApplyColorAndOpacityProperties(renderer);
 
     mitk::ColorProperty::Pointer colorprop =
       dynamic_cast<mitk::ColorProperty *>(dataNode->GetProperty("contour.color", renderer));
     float opacity = 0.5;
     dataNode->GetFloatProperty("opacity", opacity, renderer);
 
     if (colorprop)
     {
       // set the color of the contour
       double red = colorprop->GetColor().GetRed();
       double green = colorprop->GetColor().GetGreen();
       double blue = colorprop->GetColor().GetBlue();
       glColor4f(red, green, blue, opacity);
     }
 
     mitk::ColorProperty::Pointer selectedcolor =
       dynamic_cast<mitk::ColorProperty *>(dataNode->GetProperty("contour.points.color", renderer));
     if (!selectedcolor)
     {
       selectedcolor = mitk::ColorProperty::New(1.0, 0.0, 0.1);
     }
 
     vtkLinearTransform *transform = dataNode->GetVtkTransform();
 
     //    ContourModel::OutputType point;
     mitk::Point3D point;
 
     mitk::Point3D p;
     float vtkp[3];
     float lineWidth = 3.0;
 
     bool drawit = false;
 
     bool isHovering = false;
     dataNode->GetBoolProperty("contour.hovering", isHovering);
 
     if (isHovering)
       dataNode->GetFloatProperty("contour.hovering.width", lineWidth);
     else
       dataNode->GetFloatProperty("contour.width", lineWidth);
 
     bool showSegments = false;
     dataNode->GetBoolProperty("contour.segments.show", showSegments);
 
     bool showControlPoints = false;
     dataNode->GetBoolProperty("contour.controlpoints.show", showControlPoints);
 
     bool showPoints = false;
     dataNode->GetBoolProperty("contour.points.show", showPoints);
 
     bool showPointsNumbers = false;
     dataNode->GetBoolProperty("contour.points.text", showPointsNumbers);
 
     bool showControlPointsNumbers = false;
     dataNode->GetBoolProperty("contour.controlpoints.text", showControlPointsNumbers);
 
     bool projectmode = false;
     dataNode->GetVisibility(projectmode, renderer, "contour.project-onto-plane");
 
     mitk::ContourModel::VertexIterator pointsIt = renderingContour->IteratorBegin(timestep);
 
     Point2D pt2d; // projected_p in display coordinates
     Point2D lastPt2d;
 
     int index = 0;
 
     mitk::ScalarType maxDiff = 0.25;
 
     while (pointsIt != renderingContour->IteratorEnd(timestep))
     {
       lastPt2d = pt2d;
 
       point = (*pointsIt)->Coordinates;
 
       itk2vtk(point, vtkp);
       transform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp, p);
 
       renderer->WorldToDisplay(p, pt2d);
 
       ScalarType scalardiff = fabs(renderer->GetCurrentWorldPlaneGeometry()->SignedDistance(p));
 
       // project to plane
       if (projectmode)
       {
         drawit = true;
       }
       else if (scalardiff < maxDiff) // point is close enough to be drawn
       {
         drawit = true;
       }
       else
       {
         drawit = false;
       }
 
       // draw line
       if (drawit)
       {
         if (showSegments)
         {
           // lastPt2d is not valid in first step
           if (!(pointsIt == renderingContour->IteratorBegin(timestep)))
           {
             glLineWidth(lineWidth);
             glBegin(GL_LINES);
             glVertex2f(pt2d[0], pt2d[1]);
             glVertex2f(lastPt2d[0], lastPt2d[1]);
             glEnd();
             glLineWidth(1);
           }
         }
 
         if (showControlPoints)
         {
-          // draw ontrol points
+          // draw control points
           if ((*pointsIt)->IsControlPoint)
           {
             float pointsize = 4;
             Point2D tmp;
 
             Vector2D horz, vert;
             horz[1] = 0;
             vert[0] = 0;
             horz[0] = pointsize;
             vert[1] = pointsize;
             glColor3f(selectedcolor->GetColor().GetRed(),
                       selectedcolor->GetColor().GetBlue(),
                       selectedcolor->GetColor().GetGreen());
             glLineWidth(1);
             // a rectangle around the point with the selected color
             glBegin(GL_LINE_LOOP);
             tmp = pt2d - horz;
             glVertex2dv(&tmp[0]);
             tmp = pt2d + vert;
             glVertex2dv(&tmp[0]);
             tmp = pt2d + horz;
             glVertex2dv(&tmp[0]);
             tmp = pt2d - vert;
             glVertex2dv(&tmp[0]);
             glEnd();
             glLineWidth(1);
             // the actual point in the specified color to see the usual color of the point
             glColor3f(
               colorprop->GetColor().GetRed(), colorprop->GetColor().GetGreen(), colorprop->GetColor().GetBlue());
             glPointSize(1);
             glBegin(GL_POINTS);
             tmp = pt2d;
             glVertex2dv(&tmp[0]);
             glEnd();
           }
         }
 
         if (showPoints)
         {
           float pointsize = 3;
           Point2D tmp;
 
           Vector2D horz, vert;
           horz[1] = 0;
           vert[0] = 0;
           horz[0] = pointsize;
           vert[1] = pointsize;
           glColor3f(0.0, 0.0, 0.0);
           glLineWidth(1);
           // a rectangle around the point with the selected color
           glBegin(GL_LINE_LOOP);
           tmp = pt2d - horz;
           glVertex2dv(&tmp[0]);
           tmp = pt2d + vert;
           glVertex2dv(&tmp[0]);
           tmp = pt2d + horz;
           glVertex2dv(&tmp[0]);
           tmp = pt2d - vert;
           glVertex2dv(&tmp[0]);
           glEnd();
           glLineWidth(1);
           // the actual point in the specified color to see the usual color of the point
           glColor3f(colorprop->GetColor().GetRed(), colorprop->GetColor().GetGreen(), colorprop->GetColor().GetBlue());
           glPointSize(1);
           glBegin(GL_POINTS);
           tmp = pt2d;
           glVertex2dv(&tmp[0]);
           glEnd();
         }
 
         if (showPointsNumbers)
         {
           std::string l;
           std::stringstream ss;
           ss << index;
           l.append(ss.str());
 
           float rgb[3];
           rgb[0] = 0.0;
           rgb[1] = 0.0;
           rgb[2] = 0.0;
 
           WriteTextWithAnnotation(m_PointNumbersAnnotation, l.c_str(), rgb, pt2d, renderer);
         }
 
         if (showControlPointsNumbers && (*pointsIt)->IsControlPoint)
         {
           std::string l;
           std::stringstream ss;
           ss << index;
           l.append(ss.str());
 
           float rgb[3];
           rgb[0] = 1.0;
           rgb[1] = 1.0;
           rgb[2] = 0.0;
 
           WriteTextWithAnnotation(m_ControlPointNumbersAnnotation, l.c_str(), rgb, pt2d, renderer);
         }
 
         index++;
       }
 
       pointsIt++;
     } // end while iterate over controlpoints
 
     // close contour if necessary
     if (renderingContour->IsClosed(timestep) && drawit && showSegments)
     {
       lastPt2d = pt2d;
       point = renderingContour->GetVertexAt(0, timestep)->Coordinates;
       itk2vtk(point, vtkp);
       transform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp, p);
       renderer->WorldToDisplay(p, pt2d);
 
       glLineWidth(lineWidth);
       glBegin(GL_LINES);
       glVertex2f(lastPt2d[0], lastPt2d[1]);
       glVertex2f(pt2d[0], pt2d[1]);
       glEnd();
       glLineWidth(1);
     }
 
     // draw selected vertex if exists
     if (renderingContour->GetSelectedVertex())
     {
       // transform selected vertex
       point = renderingContour->GetSelectedVertex()->Coordinates;
 
       itk2vtk(point, vtkp);
       transform->TransformPoint(vtkp, vtkp);
       vtk2itk(vtkp, p);
 
       renderer->WorldToDisplay(p, pt2d);
 
       ScalarType scalardiff = fabs(renderer->GetCurrentWorldPlaneGeometry()->SignedDistance(p));
       //----------------------------------
 
       // draw point if close to plane
       if (scalardiff < maxDiff)
       {
         float pointsize = 5;
         Point2D tmp;
         glColor3f(0.0, 1.0, 0.0);
         glLineWidth(1);
         // a diamond around the point
         glBegin(GL_LINE_LOOP);
         // begin from upper left corner and paint clockwise
         tmp[0] = pt2d[0] - pointsize;
         tmp[1] = pt2d[1] + pointsize;
         glVertex2dv(&tmp[0]);
         tmp[0] = pt2d[0] + pointsize;
         tmp[1] = pt2d[1] + pointsize;
         glVertex2dv(&tmp[0]);
         tmp[0] = pt2d[0] + pointsize;
         tmp[1] = pt2d[1] - pointsize;
         glVertex2dv(&tmp[0]);
         tmp[0] = pt2d[0] - pointsize;
         tmp[1] = pt2d[1] - pointsize;
         glVertex2dv(&tmp[0]);
         glEnd();
       }
       //------------------------------------
     }
   }
 }
 
 void mitk::ContourModelSetGLMapper2D::SetDefaultProperties(mitk::DataNode *node,
                                                            mitk::BaseRenderer *renderer,
                                                            bool overwrite)
 {
   node->AddProperty("contour.color", ColorProperty::New(0.9, 1.0, 0.1), renderer, overwrite);
   node->AddProperty("contour.points.color", ColorProperty::New(1.0, 0.0, 0.1), renderer, overwrite);
   node->AddProperty("contour.points.show", mitk::BoolProperty::New(false), renderer, overwrite);
   node->AddProperty("contour.segments.show", mitk::BoolProperty::New(true), renderer, overwrite);
   node->AddProperty("contour.controlpoints.show", mitk::BoolProperty::New(false), renderer, overwrite);
   node->AddProperty("contour.width", mitk::FloatProperty::New(1.0), renderer, overwrite);
   node->AddProperty("contour.hovering.width", mitk::FloatProperty::New(3.0), renderer, overwrite);
   node->AddProperty("contour.hovering", mitk::BoolProperty::New(false), renderer, overwrite);
   node->AddProperty("contour.points.text", mitk::BoolProperty::New(false), renderer, overwrite);
   node->AddProperty("contour.controlpoints.text", mitk::BoolProperty::New(false), renderer, overwrite);
 
   node->AddProperty("contour.project-onto-plane", mitk::BoolProperty::New(false), renderer, overwrite);
 
   node->AddProperty("opacity", mitk::FloatProperty::New(1.0f), renderer, overwrite);
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }
diff --git a/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.h b/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.h
index 53279d9919..cc3e919507 100644
--- a/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.h
+++ b/Modules/ContourModel/Rendering/mitkContourModelSetGLMapper2D.h
@@ -1,70 +1,70 @@
 /*===================================================================
 
 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 MITK_ContourModelSetGLMapper2D_H_
 #define MITK_ContourModelSetGLMapper2D_H_
 
 #include "mitkBaseRenderer.h"
 #include "mitkCommon.h"
 #include "mitkContourModelGLMapper2DBase.h"
 #include "mitkContourModelSet.h"
 #include <MitkContourModelExports.h>
 
 namespace mitk
 {
   class BaseRenderer;
   class ContourModel;
 
   /**
   * @brief OpenGL-based mapper to display a mitk::ContourModelSet object containing several contours in a 2D render
   * window
   *
   *
   * @ingroup MitkContourModelModule
   */
   class MITKCONTOURMODEL_EXPORT ContourModelSetGLMapper2D : public ContourModelGLMapper2DBase
   {
   public:
     mitkClassMacro(ContourModelSetGLMapper2D, ContourModelGLMapper2DBase);
 
     itkFactorylessNewMacro(Self) itkCloneMacro(Self)
 
       /**
       * reimplemented from Baseclass
       */
       virtual void Paint(BaseRenderer *renderer) override;
 
     static void SetDefaultProperties(mitk::DataNode *node, mitk::BaseRenderer *renderer = NULL, bool overwrite = false);
 
     LocalStorageHandler<BaseLocalStorage> m_LSH;
 
   protected:
     ContourModelSetGLMapper2D();
 
     virtual ~ContourModelSetGLMapper2D();
 
     void InternalDrawContour(mitk::ContourModel *contour, mitk::BaseRenderer *renderer) override;
 
   private:
     /**
-    * return a refernce of the rendered data object
+    * return a reference of the rendered data object
     */
     ContourModelSet *GetInput(void);
   };
 
 } // namespace mitk
 
 #endif
diff --git a/Modules/ContourModel/Rendering/mitkContourModelSetMapper3D.cpp b/Modules/ContourModel/Rendering/mitkContourModelSetMapper3D.cpp
index ef3bc6282d..b8c6745739 100644
--- a/Modules/ContourModel/Rendering/mitkContourModelSetMapper3D.cpp
+++ b/Modules/ContourModel/Rendering/mitkContourModelSetMapper3D.cpp
@@ -1,236 +1,236 @@
 /*===================================================================
 
 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 <mitkContourModelSetMapper3D.h>
 
 #include "mitkSurface.h"
 #include <vtkCellArray.h>
 #include <vtkPoints.h>
 #include <vtkPolyLine.h>
 #include <vtkProperty.h>
 
 mitk::ContourModelSetMapper3D::ContourModelSetMapper3D()
 {
 }
 
 mitk::ContourModelSetMapper3D::~ContourModelSetMapper3D()
 {
 }
 
 const mitk::ContourModelSet *mitk::ContourModelSetMapper3D::GetInput(void)
 {
-  // convient way to get the data from the dataNode
+  // convenient way to get the data from the dataNode
   return static_cast<const mitk::ContourModelSet *>(GetDataNode()->GetData());
 }
 
 vtkProp *mitk::ContourModelSetMapper3D::GetVtkProp(mitk::BaseRenderer *renderer)
 {
   // return the actor corresponding to the renderer
   return m_LSH.GetLocalStorage(renderer)->m_Assembly;
 }
 
 void mitk::ContourModelSetMapper3D::GenerateDataForRenderer(mitk::BaseRenderer *renderer)
 {
   /* First convert the contourModel to vtkPolyData, then tube filter it and
    * set it input for our mapper
    */
 
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   ContourModelSet *contourModelSet = dynamic_cast<ContourModelSet *>(this->GetDataNode()->GetData());
 
   if (contourModelSet != NULL)
   {
     vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
     vtkSmartPointer<vtkCellArray> cells = vtkSmartPointer<vtkCellArray>::New();
     vtkIdType baseIndex = 0;
 
     ContourModelSet::ContourModelSetIterator it = contourModelSet->Begin();
     ContourModelSet::ContourModelSetIterator end = contourModelSet->End();
 
     while (it != end)
     {
       ContourModel *contourModel = it->GetPointer();
 
       ContourModel::VertexIterator vertIt = contourModel->Begin();
       ContourModel::VertexIterator vertEnd = contourModel->End();
 
       while (vertIt != vertEnd)
       {
         points->InsertNextPoint((*vertIt)->Coordinates[0], (*vertIt)->Coordinates[1], (*vertIt)->Coordinates[2]);
         ++vertIt;
       }
 
       vtkSmartPointer<vtkPolyLine> line = vtkSmartPointer<vtkPolyLine>::New();
       vtkIdList *pointIds = line->GetPointIds();
 
       vtkIdType numPoints = contourModel->GetNumberOfVertices();
       pointIds->SetNumberOfIds(numPoints + 1);
 
       for (vtkIdType i = 0; i < numPoints; ++i)
         pointIds->SetId(i, baseIndex + i);
 
       pointIds->SetId(numPoints, baseIndex);
 
       cells->InsertNextCell(line);
 
       baseIndex += numPoints;
 
       ++it;
     }
 
     vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
     polyData->SetPoints(points);
     polyData->SetLines(cells);
 
     vtkSmartPointer<vtkPolyDataMapper> mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
     vtkSmartPointer<vtkActor> actor = vtkSmartPointer<vtkActor>::New();
     actor->SetMapper(mapper);
 
     mapper->SetInputData(polyData);
 
     localStorage->m_Assembly->AddPart(actor);
   }
   this->ApplyContourProperties(renderer);
   this->ApplyContourModelSetProperties(renderer);
 }
 
 void mitk::ContourModelSetMapper3D::Update(mitk::BaseRenderer *renderer)
 {
   bool visible = true;
   GetDataNode()->GetVisibility(visible, renderer, "visible");
 
   mitk::ContourModel *data = static_cast<mitk::ContourModel *>(GetDataNode()->GetData());
   if (data == NULL)
   {
     return;
   }
 
   // Calculate time step of the input data for the specified renderer (integer value)
   this->CalculateTimeStep(renderer);
 
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   if (this->GetTimestep() == -1)
   {
     return;
   }
 
   const DataNode *node = this->GetDataNode();
   data->UpdateOutputInformation();
 
   // check if something important has changed and we need to rerender
   if ((localStorage->m_LastUpdateTime < node->GetMTime()) // was the node modified?
       ||
       (localStorage->m_LastUpdateTime < data->GetPipelineMTime()) // Was the data modified?
       ||
       (localStorage->m_LastUpdateTime <
        renderer->GetCurrentWorldPlaneGeometryUpdateTime()) // was the geometry modified?
       ||
       (localStorage->m_LastUpdateTime < renderer->GetCurrentWorldPlaneGeometry()->GetMTime()) ||
       (localStorage->m_LastUpdateTime < node->GetPropertyList()->GetMTime()) // was a property modified?
       ||
       (localStorage->m_LastUpdateTime < node->GetPropertyList(renderer)->GetMTime()))
   {
     this->GenerateDataForRenderer(renderer);
   }
 
   // since we have checked that nothing important has changed, we can set
   // m_LastUpdateTime to the current time
   localStorage->m_LastUpdateTime.Modified();
 }
 
 vtkSmartPointer<vtkPolyData> mitk::ContourModelSetMapper3D::CreateVtkPolyDataFromContour(
   mitk::ContourModel *inputContour, mitk::BaseRenderer *renderer)
 {
   unsigned int timestep = this->GetTimestep();
 
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   localStorage->m_contourToPolyData->SetInput(inputContour);
   localStorage->m_contourToPolyData->Update();
 
   vtkSmartPointer<vtkPolyData> polyData = vtkSmartPointer<vtkPolyData>::New();
   polyData = localStorage->m_contourToPolyData->GetOutput()->GetVtkPolyData(timestep);
 
   return polyData;
 }
 
 void mitk::ContourModelSetMapper3D::ApplyContourModelSetProperties(BaseRenderer *renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
   DataNode *dataNode = this->GetDataNode();
 
   if (dataNode != NULL)
   {
     float lineWidth = 1;
     dataNode->GetFloatProperty("contour.3D.width", lineWidth, renderer);
 
     vtkSmartPointer<vtkPropCollection> collection = vtkSmartPointer<vtkPropCollection>::New();
     localStorage->m_Assembly->GetActors(collection);
     collection->InitTraversal();
     for (vtkIdType i = 0; i < collection->GetNumberOfItems(); i++)
     {
       vtkActor::SafeDownCast(collection->GetNextProp())->GetProperty()->SetLineWidth(lineWidth);
     }
   }
 }
 
 void mitk::ContourModelSetMapper3D::ApplyContourProperties(mitk::BaseRenderer *renderer)
 {
   LocalStorage *localStorage = m_LSH.GetLocalStorage(renderer);
 
   mitk::ColorProperty::Pointer colorprop =
     dynamic_cast<mitk::ColorProperty *>(GetDataNode()->GetProperty("contour.color", renderer));
   if (colorprop)
   {
     // set the color of the contour
     double red = colorprop->GetColor().GetRed();
     double green = colorprop->GetColor().GetGreen();
     double blue = colorprop->GetColor().GetBlue();
 
     vtkSmartPointer<vtkPropCollection> collection = vtkSmartPointer<vtkPropCollection>::New();
     localStorage->m_Assembly->GetActors(collection);
     collection->InitTraversal();
     for (vtkIdType i = 0; i < collection->GetNumberOfItems(); i++)
     {
       vtkActor::SafeDownCast(collection->GetNextProp())->GetProperty()->SetColor(red, green, blue);
     }
   }
 }
 
 /*+++++++++++++++++++ LocalStorage part +++++++++++++++++++++++++*/
 
 mitk::ContourModelSetMapper3D::LocalStorage *mitk::ContourModelSetMapper3D::GetLocalStorage(
   mitk::BaseRenderer *renderer)
 {
   return m_LSH.GetLocalStorage(renderer);
 }
 
 mitk::ContourModelSetMapper3D::LocalStorage::LocalStorage()
 {
   m_Assembly = vtkSmartPointer<vtkAssembly>::New();
   m_contourToPolyData = mitk::ContourModelToSurfaceFilter::New();
 }
 
 void mitk::ContourModelSetMapper3D::SetDefaultProperties(mitk::DataNode *node,
                                                          mitk::BaseRenderer *renderer,
                                                          bool overwrite)
 {
   node->AddProperty("color", ColorProperty::New(1.0, 0.0, 0.0), renderer, overwrite);
   node->AddProperty("contour.3D.width", mitk::FloatProperty::New(0.5), renderer, overwrite);
 
   Superclass::SetDefaultProperties(node, renderer, overwrite);
 }