diff --git a/Modules/ContourModel/DataManagement/mitkContourElement.cpp b/Modules/ContourModel/DataManagement/mitkContourElement.cpp
index db490e8ae7..05808cb01c 100644
--- a/Modules/ContourModel/DataManagement/mitkContourElement.cpp
+++ b/Modules/ContourModel/DataManagement/mitkContourElement.cpp
@@ -1,504 +1,502 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #include <algorithm>
 #include <mitkContourElement.h>
 #include <vtkMath.h>
 
 bool mitk::ContourElement::ContourModelVertex::operator==(const ContourModelVertex &other) const
 {
   return this->Coordinates == other.Coordinates && this->IsControlPoint == other.IsControlPoint;
 }
 
 mitk::ContourElement::ConstVertexIterator mitk::ContourElement::ConstIteratorBegin() const
 {
   return this->begin();
 }
 
 mitk::ContourElement::ConstVertexIterator mitk::ContourElement::ConstIteratorEnd() const
 {
   return this->end();
 }
 
 mitk::ContourElement::VertexIterator mitk::ContourElement::IteratorBegin()
 {
   return this->begin();
 }
 
 mitk::ContourElement::VertexIterator mitk::ContourElement::IteratorEnd()
 {
   return this->end();
 }
 
 mitk::ContourElement::ConstVertexIterator mitk::ContourElement::begin() const
 {
   return this->m_Vertices.begin();
 }
 
 mitk::ContourElement::ConstVertexIterator mitk::ContourElement::end() const
 {
   return this->m_Vertices.end();
 }
 
 mitk::ContourElement::VertexIterator mitk::ContourElement::begin()
 {
   return this->m_Vertices.begin();
 }
 
 mitk::ContourElement::VertexIterator mitk::ContourElement::end()
 {
   return this->m_Vertices.end();
 }
 
 mitk::ContourElement::ContourElement(const mitk::ContourElement &other)
   : itk::LightObject(), m_IsClosed(other.m_IsClosed)
 {
   for (const auto &v : other.m_Vertices)
   {
     m_Vertices.push_back(new ContourModelVertex(*v));
   }
 }
 
 mitk::ContourElement &mitk::ContourElement::operator=(const ContourElement &other)
 {
   if (this != &other)
   {
     this->Clear();
     for (const auto &v : other.m_Vertices)
     {
       m_Vertices.push_back(new ContourModelVertex(*v));
     }
   }
 
   this->m_IsClosed = other.m_IsClosed;
   return *this;
 }
 
 mitk::ContourElement::~ContourElement()
 {
   this->Clear();
 }
 
 mitk::ContourElement::VertexSizeType mitk::ContourElement::GetSize() const
 {
   return this->m_Vertices.size();
 }
 
 void mitk::ContourElement::AddVertex(const mitk::Point3D &vertex, bool isControlPoint)
 {
   this->m_Vertices.push_back(new VertexType(vertex, isControlPoint));
 }
 
 void mitk::ContourElement::AddVertexAtFront(const mitk::Point3D &vertex, bool isControlPoint)
 {
   this->m_Vertices.push_front(new VertexType(vertex, isControlPoint));
 }
 
 void mitk::ContourElement::InsertVertexAtIndex(const mitk::Point3D &vertex, bool isControlPoint, VertexSizeType index)
 {
   if (index >= 0 && this->GetSize() > index)
   {
     auto _where = this->m_Vertices.begin();
     _where += index;
     this->m_Vertices.insert(_where, new VertexType(vertex, isControlPoint));
   }
 }
 
 void mitk::ContourElement::SetVertexAt(VertexSizeType pointId, const Point3D &point)
 {
   if (pointId >= 0 && this->GetSize() > pointId)
   {
     this->m_Vertices[pointId]->Coordinates = point;
   }
 }
 
 void mitk::ContourElement::SetVertexAt(VertexSizeType pointId, const VertexType *vertex)
 {
   if (nullptr == vertex)
   {
     mitkThrow() << "Cannot set vertex. Passed vertex instance is invalid. Index to set: " << pointId;
   }
 
   if (pointId >= 0 && this->GetSize() > pointId)
   {
     this->m_Vertices[pointId]->Coordinates = vertex->Coordinates;
     this->m_Vertices[pointId]->IsControlPoint = vertex->IsControlPoint;
   }
 }
 
 mitk::ContourElement::VertexType *mitk::ContourElement::GetVertexAt(VertexSizeType index)
 {
   return this->m_Vertices.at(index);
 }
 
 const mitk::ContourElement::VertexType *mitk::ContourElement::GetVertexAt(VertexSizeType index) const
 {
   return this->m_Vertices.at(index);
 }
 
 bool mitk::ContourElement::IsEmpty() const
 {
   return this->m_Vertices.empty();
 }
 
 mitk::ContourElement::VertexType *mitk::ContourElement::GetControlVertexAt(const mitk::Point3D &point, float eps)
 {
   /* current version iterates over the whole deque - should some kind of an octree with spatial query*/
 
   if (eps > 0)
   {
     // currently no method with better performance is available
     return BruteForceGetVertexAt(point, eps, true);
   } // if eps < 0
   return nullptr;
 }
 
 mitk::ContourElement::VertexType *mitk::ContourElement::GetVertexAt(const mitk::Point3D &point, float eps)
 {
   /* current version iterates over the whole deque - should some kind of an octree with spatial query*/
 
   if (eps > 0)
   {
     // currently no method with better performance is available
     return BruteForceGetVertexAt(point, eps);
   } // if eps < 0
   return nullptr;
 }
 
 mitk::ContourElement::VertexType *mitk::ContourElement::GetNextVertexAt(const mitk::Point3D &point, float eps)
 {
   /* current version iterates over the whole deque - should some kind of an octree with spatial query*/
 
   if (eps > 0)
   {
     // currently no method with better performance is available
     return BruteForceGetVertexAt(point, eps, true, 1);
   } // if eps < 0
   return nullptr;
 }
 
 mitk::ContourElement::VertexType *mitk::ContourElement::GetPreviousVertexAt(const mitk::Point3D &point, float eps)
 {
   /* current version iterates over the whole deque - should some kind of an octree with spatial query*/
 
   if (eps > 0)
   {
     // currently no method with better performance is available
     return BruteForceGetVertexAt(point, eps, true, -1);
   } // if eps < 0
   return nullptr;
 }
 
 mitk::ContourElement::VertexType *mitk::ContourElement::BruteForceGetVertexAt(const mitk::Point3D &point,
                                                                               double eps,
                                                                               bool isControlPoint,
                                                                               int offset)
 {
   VertexListType verticesList;
 
   if (isControlPoint)
   {
     verticesList = this->GetControlVertexList();
   }
   else
   {
     verticesList = *this->GetVertexList();
   }
 
-  int vertexIndex = BruteForceGetVertexIndexAt(point, eps, verticesList, isControlPoint);
+  int vertexIndex = BruteForceGetVertexIndexAt(point, eps, verticesList);
 
   if (vertexIndex!=-1)
   {
     vertexIndex += offset;
-    auto size = (int) verticesList.size();
 
     if (vertexIndex < 0)
     {
       // for negative offset
       // if the offset exceeds the first vertex, we start from the end of the vertex list backwards
       vertexIndex = verticesList.size() + offset;
     }
-    else if (vertexIndex >= verticesList.size())
+    else if (vertexIndex >= (int) verticesList.size())
     {
       // if the offset exceeds the last vertex, we start from the beginning of the vertex list
       vertexIndex = vertexIndex - verticesList.size();
     }
 
     return verticesList[vertexIndex];
   }
   return nullptr;
 }
 
 int mitk::ContourElement::BruteForceGetVertexIndexAt(const mitk::Point3D &point,
                                                      double eps,
-                                                     VertexListType verticesList,
-                                                     bool isControlPoint)
+                                                     VertexListType verticesList)
 {
   if (eps < 0)
   {
     mitkThrow() << "Distance cannot be negative";
   }
 
   ConstVertexIterator nearestPointIterator;
   bool nearestPointIsInitialized = false;
 
   ConstVertexIterator it = verticesList.begin();
   ConstVertexIterator end = verticesList.end();
 
   while (it != end)
   {
     mitk::Point3D currentPoint = (*it)->Coordinates;
 
     double distance = currentPoint.EuclideanDistanceTo(point);
     if (distance < eps)
     {
       if (!nearestPointIsInitialized || distance < (*nearestPointIterator)->Coordinates.EuclideanDistanceTo(point))
       {
         nearestPointIterator = it;
         nearestPointIsInitialized = true;
       }
     } // if distance > eps
 
     it++;
   } // while
 
   if (nearestPointIsInitialized)
   {
     return nearestPointIterator - verticesList.begin();
   }
   return -1;
 }
 
 const mitk::ContourElement::VertexListType *mitk::ContourElement::GetVertexList() const
 {
   return &(this->m_Vertices);
 }
 
 const mitk::ContourElement::VertexListType mitk::ContourElement::GetControlVertexList() const
 {
   VertexListType allList = (this->m_Vertices);
   VertexListType out;
 
   ConstVertexIterator begin = allList.begin();
 
   ConstVertexIterator end = allList.end();
 
   std::copy_if(begin, end, std::back_inserter(out), [](VertexType *i) { return i->IsControlPoint; });
   // std::copy(begin, end, std::back_inserter(out));
   return out;
   // return &(this->m_Vertices);
 }
 
 bool mitk::ContourElement::IsClosed() const
 {
   return this->m_IsClosed;
 }
 
 bool mitk::ContourElement::IsNearContour(const mitk::Point3D &point, float eps) const
 {
   ConstVertexIterator it1 = this->m_Vertices.begin();
   ConstVertexIterator it2 = this->m_Vertices.begin();
   it2++; // it2 runs one position ahead
 
   ConstVertexIterator end = this->m_Vertices.end();
 
   int counter = 0;
 
   for (; it1 != end; it1++, it2++, counter++)
   {
     if (it2 == end)
       it2 = this->m_Vertices.begin();
 
     mitk::Point3D v1 = (*it1)->Coordinates;
     mitk::Point3D v2 = (*it2)->Coordinates;
 
     const float l2 = v1.SquaredEuclideanDistanceTo(v2);
 
     mitk::Vector3D p_v1 = point - v1;
     mitk::Vector3D v2_v1 = v2 - v1;
 
     double tc = (p_v1 * v2_v1) / l2;
 
     // take into account we have line segments and not (infinite) lines
     if (tc < 0.0)
       tc = 0.0;
     if (tc > 1.0)
       tc = 1.0;
 
     mitk::Point3D crossPoint = v1 + v2_v1 * tc;
 
     double distance = point.SquaredEuclideanDistanceTo(crossPoint);
 
     if (distance < eps)
     {
       return true;
     }
   }
 
   return false;
 }
 
 void mitk::ContourElement::Close()
 {
   this->m_IsClosed = true;
 }
 
 void mitk::ContourElement::Open()
 {
   this->m_IsClosed = false;
 }
 
 void mitk::ContourElement::SetClosed(bool isClosed)
 {
   isClosed ? this->Close() : this->Open();
 }
 
 mitk::ContourElement::VertexListType mitk::ContourElement::GetControlVertices() const
 {
   VertexListType controlVertices;
 
   std::copy_if(
     this->m_Vertices.begin(), this->m_Vertices.end(), std::back_inserter(controlVertices), [](const VertexType *v) {
       return v->IsControlPoint;
     });
 
   return controlVertices;
 }
 
 void mitk::ContourElement::Concatenate(const mitk::ContourElement *other, bool check)
 {
   if (other->GetSize() > 0)
   {
     for (const auto &sourceVertex : other->m_Vertices)
     {
       if (check)
       {
         auto finding =
           std::find_if(this->m_Vertices.begin(), this->m_Vertices.end(), [sourceVertex](const VertexType *v) {
             return sourceVertex->Coordinates == v->Coordinates;
           });
 
         if (finding == this->m_Vertices.end())
         {
           this->m_Vertices.push_back(new ContourModelVertex(*sourceVertex));
         }
       }
       else
       {
         this->m_Vertices.push_back(new ContourModelVertex(*sourceVertex));
       }
     }
   }
 }
 
 mitk::ContourElement::VertexSizeType mitk::ContourElement::GetIndex(const VertexType *vertex) const
 {
   VertexSizeType result = NPOS;
 
   auto finding = std::find(this->m_Vertices.begin(), this->m_Vertices.end(), vertex);
 
   if (finding != this->m_Vertices.end())
   {
     result = finding - this->m_Vertices.begin();
   }
 
   return result;
 }
 
 bool mitk::ContourElement::RemoveVertex(const VertexType *vertex)
 {
   auto finding = std::find(this->m_Vertices.begin(), this->m_Vertices.end(), vertex);
 
   return RemoveVertexByIterator(finding);
 }
 
 bool mitk::ContourElement::RemoveVertexAt(VertexSizeType index)
 {
   if (index >= 0 && index < this->m_Vertices.size())
   {
     auto delIter = this->m_Vertices.begin() + index;
     return RemoveVertexByIterator(delIter);
   }
 
   return false;
 }
 
 bool mitk::ContourElement::RemoveVertexAt(const mitk::Point3D &point, double eps)
 {
   if (eps > 0)
   {
     auto finding = std::find_if(this->m_Vertices.begin(), this->m_Vertices.end(), [point, eps](const VertexType *v) {
       return v->Coordinates.EuclideanDistanceTo(point) < eps;
     });
 
     return RemoveVertexByIterator(finding);
   }
   return false;
 }
 
 bool mitk::ContourElement::RemoveVertexByIterator(VertexListType::iterator &iter)
 {
   if (iter != this->m_Vertices.end())
   {
     delete *iter;
     this->m_Vertices.erase(iter);
     return true;
   }
 
   return false;
 }
 
 void mitk::ContourElement::Clear()
 {
   for (auto vertex : m_Vertices)
   {
     delete vertex;
   }
   this->m_Vertices.clear();
 }
 
 //----------------------------------------------------------------------
 void mitk::ContourElement::RedistributeControlVertices(const VertexType *selected, int period)
 {
   int counter = 0;
   auto _where = this->m_Vertices.begin();
 
   if (selected != nullptr)
   {
     auto finding = std::find(this->m_Vertices.begin(), this->m_Vertices.end(), selected);
 
     if (finding != this->m_Vertices.end())
     {
       _where = finding;
     }
   }
 
   auto _iter = _where;
   while (_iter != this->m_Vertices.end())
   {
     div_t divresult;
     divresult = div(counter, period);
     (*_iter)->IsControlPoint = (divresult.rem == 0);
     counter++;
     _iter++;
   }
 
   _iter = _where;
   counter = 0;
   while (_iter != this->m_Vertices.begin())
   {
     div_t divresult;
     divresult = div(counter, period);
     (*_iter)->IsControlPoint = (divresult.rem == 0);
     counter++;
     _iter--;
   }
 }
diff --git a/Modules/ContourModel/DataManagement/mitkContourElement.h b/Modules/ContourModel/DataManagement/mitkContourElement.h
index 85047a36de..f364a4b928 100644
--- a/Modules/ContourModel/DataManagement/mitkContourElement.h
+++ b/Modules/ContourModel/DataManagement/mitkContourElement.h
@@ -1,281 +1,280 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 #ifndef _mitkContourElement_H_
 #define _mitkContourElement_H_
 
 #include "mitkCommon.h"
 #include <MitkContourModelExports.h>
 #include <mitkNumericTypes.h>
 
 #include <deque>
 
 namespace mitk
 {
   /** \brief Represents a contour in 3D space.
   A ContourElement is consisting of linked vertices implicitely defining the contour.
   They are stored in a double ended queue making it possible to add vertices at front and
   end of the contour and to iterate in both directions.
   To mark a vertex as a special one it can be set as a control point.
 
   \note This class assumes that it manages its vertices. So if a vertex instance is added to this
   class the ownership of the vertex is transfered to the ContourElement instance.
   The ContourElement instance takes care of deleting vertex instances if needed.
   It is highly not recommend to use this class directly as it is designed as a internal class of
   ContourModel. Therefore it is adviced to use ContourModel if contour representations are needed in
   MITK.
   */
   class MITKCONTOURMODEL_EXPORT ContourElement : public itk::LightObject
   {
   public:
     mitkClassMacroItkParent(ContourElement, itk::LightObject);
 
     itkFactorylessNewMacro(Self);
 
     itkCloneMacro(Self);
 
     /** \brief Represents a single vertex of a contour.
     */
     struct MITKCONTOURMODEL_EXPORT ContourModelVertex
     {
       ContourModelVertex(const mitk::Point3D& point, bool active = false) : IsControlPoint(active), Coordinates(point) {};
       ContourModelVertex(const ContourModelVertex& other)
         : IsControlPoint(other.IsControlPoint), Coordinates(other.Coordinates)
       {
       };
 
       /** \brief Treat point special. */
       bool IsControlPoint;
 
       /** \brief Coordinates in 3D space. */
       mitk::Point3D Coordinates;
 
       bool operator ==(const ContourModelVertex& other) const;
     };
 
     using VertexType = ContourModelVertex;
     using VertexListType = std::deque<VertexType*>;
     using VertexIterator = VertexListType::iterator;
     using ConstVertexIterator = VertexListType::const_iterator;
     using VertexSizeType = VertexListType::size_type;
 
     /**Indicates an invalid index.
      * It is always the maximum of the unsigned int type.*/
     static const VertexSizeType NPOS = -1;
 
     /** \brief Return a const iterator a the front.
     */
     ConstVertexIterator ConstIteratorBegin() const;
     /** \brief Return a const iterator a the end.
     */
     ConstVertexIterator ConstIteratorEnd() const;
     /** \brief Return an iterator a the front.
     */
     VertexIterator IteratorBegin();
     /** \brief Return an iterator a the end.
     */
     VertexIterator IteratorEnd();
 
     /** \brief Return a const iterator a the front.
     * For easier support of stl functionality.
     */
     ConstVertexIterator begin() const;
     /** \brief Return a const iterator a the end.
     * For easier support of stl functionality.
     */
     ConstVertexIterator end() const;
     /** \brief Return an iterator a the front.
     * For easier support of stl functionality.
     */
     VertexIterator begin();
     /** \brief Return an iterator a the end.
     * For easier support of stl functionality.
     */
     VertexIterator end();
 
     /** \brief Returns the number of contained vertices.
     */
     VertexSizeType GetSize() const;
 
     /** \brief Add a vertex at the end of the contour
     \param point - coordinates in 3D space.
     \param isControlPoint - is the vertex a special control point.
     */
     void AddVertex(const mitk::Point3D &point, bool isControlPoint);
 
     /** \brief Add a vertex at the front of the contour
     \param point - coordinates in 3D space.
     \param isControlPoint - is the vertex a control point.
     */
     void AddVertexAtFront(const mitk::Point3D &point, bool isControlPoint);
 
     /** \brief Add a vertex at a given index of the contour
     \param point - coordinates in 3D space.
     \param isControlPoint - is the vertex a special control point.
     \param index - the index to be inserted at.
     */
     void InsertVertexAtIndex(const mitk::Point3D &point, bool isControlPoint, VertexSizeType index);
 
     /** \brief Set coordinates a given index.
     \param pointId Index of vertex.
     \param point Coordinates.
     */
     void SetVertexAt(VertexSizeType pointId, const mitk::Point3D &point);
 
     /** \brief Set vertex a given index (by copying the values).
     \param pointId Index of vertex.
     \param vertex Vertex.
     \pre Passed vertex is a valid instance
     */
     void SetVertexAt(VertexSizeType pointId, const VertexType* vertex);
 
     /** \brief Returns the vertex a given index
     \param index
     \pre index must be valid.
     */
     VertexType* GetVertexAt(VertexSizeType index);
     const VertexType* GetVertexAt(VertexSizeType index) const;
 
     /** \brief Returns the approximate nearest vertex a given posoition in 3D space
     \param point - query position in 3D space.
     \param eps - the error bound for search algorithm.
     */
     VertexType *GetVertexAt(const mitk::Point3D &point, float eps);
 
     VertexType *GetNextVertexAt(const mitk::Point3D &point, float eps);
 
     VertexType *GetPreviousVertexAt(const mitk::Point3D &point, float eps);
 
     /** \brief Returns the approximate nearest control vertex a given posoition in 3D space, if the clicked position is within a specific range.
       \param point - query position in 3D space.
       \param eps - the error bound for search algorithm.
       */
     VertexType *GetControlVertexAt(const mitk::Point3D &point, float eps);
 
     /** \brief Returns the index of the given vertex within the contour.
     \param vertex - the vertex to be searched.
     \return index of vertex. Returns ContourElement::NPOS if not found.
     */
     VertexSizeType GetIndex(const VertexType *vertex) const;
 
     /** \brief Returns the container of the vertices.
      */
     const VertexListType *GetVertexList() const;
 
     /** \brief Returns the container of the vertices.
      */
     const VertexListType GetControlVertexList() const;
 
     /** \brief Returns whether the contour element is empty.
     */
     bool IsEmpty() const;
 
     /** \brief Returns if the conour is closed or not.
     */
     bool IsClosed() const;
 
     /** \brief Returns whether a given point is near a contour, according to eps.
     \param point - query position in 3D space.
     \param eps - the error bound for search algorithm.
     */
     bool IsNearContour(const mitk::Point3D &point, float eps) const;
 
     /** \brief Close the contour.
     Connect first with last element.
     */
     void Close();
 
     /** \brief Open the contour.
     Disconnect first and last element.
     */
     void Open();
 
     /** \brief Set the contours IsClosed property.
     \param isClosed - true = closed; false = open;
     */
     void SetClosed(bool isClosed);
 
     /** \brief Concatenate the contuor with a another contour.
     All vertices of the other contour will be cloned and added after last vertex.
     \param other - the other contour
     \param check - set it true to avoid adding of vertices that are already in the source contour
     */
     void Concatenate(const mitk::ContourElement *other, bool check);
 
     /** \brief Remove the given vertex from the container if exists.
     \param vertex - the vertex to be removed.
     */
     bool RemoveVertex(const VertexType *vertex);
 
     /** \brief Remove a vertex at given index within the container if exists.
     \param index - the index where the vertex should be removed.
     */
     bool RemoveVertexAt(VertexSizeType index);
 
     /** \brief Remove the approximate nearest vertex at given position in 3D space if one exists.
     \param point - query point in 3D space.
     \param eps - error bound for search algorithm.
     */
     bool RemoveVertexAt(const mitk::Point3D &point, double eps);
 
     /** \brief Clear the storage container.
     */
     void Clear();
 
     /** \brief Returns the approximate nearest vertex a given position in 3D space. With the parameter 'isControlPoint', 
     one can decide if any vertex should be returned, ot just control vertices.
     \param point - query position in 3D space.
     \param eps - the error bound for search algorithm.
     \param offset - a offset to the vertex, e.g. 1 if the next vertex should be returned or -1 for the previous vertex
     */
     VertexType *BruteForceGetVertexAt(const mitk::Point3D &point, double eps, bool isControlPoint = false, int offset = 0);
 
     int BruteForceGetVertexIndexAt(const mitk::Point3D &point,
                                                       double eps,
-                                                      VertexListType verticesList,
-                                                      bool isControlPoint = false);
+                                                      VertexListType verticesList);
 
     /** Returns a list pointing to all vertices that are indicated to be control
      points.
      \remark It is important to note, that the vertex pointers in the returned
      list directly point to the vertices stored interanlly. So they are still
      owned by the ContourElement instance that returns the list. If one wants
      to take over ownership, one has to clone the vertex instances.
      */
     VertexListType GetControlVertices() const;
 
     /** \brief Uniformly redistribute control points with a given period (in number of vertices)
     \param vertex - the vertex around which the redistribution is done.
     \param period - number of vertices between control points.
     */
     void RedistributeControlVertices(const VertexType *vertex, int period);
 
   protected:
     mitkCloneMacro(Self);
 
     ContourElement() = default;
     ContourElement(const mitk::ContourElement &other);
     ~ContourElement();
 
     ContourElement& operator = (const ContourElement & other);
 
     /** Internal helper function to correctly remove the element indicated by the iterator
     from the list. After the call the iterator is invalid.
     Caller of the function must ensure that the iterator is valid!.
     \result Indicates if the element indicated by the iterator was removed. If iterator points to end it returns false.*/
     bool RemoveVertexByIterator(VertexListType::iterator& iter);
 
     VertexListType m_Vertices; // double ended queue with vertices
     bool m_IsClosed = false;
   };
 } // namespace mitk
 
 #endif // _mitkContourElement_H_