diff --git a/Modules/ContourModel/DataManagement/mitkContourElement.cpp b/Modules/ContourModel/DataManagement/mitkContourElement.cpp
index 1dac4280df..3b56894ae2 100644
--- a/Modules/ContourModel/DataManagement/mitkContourElement.cpp
+++ b/Modules/ContourModel/DataManagement/mitkContourElement.cpp
@@ -1,538 +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 BruteForceGetNextVertexAt(point, eps, true);
+    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 BruteForceGetPreviousVertexAt(point, eps, true);
+    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)
+                                                                              bool isControlPoint,
+                                                                              int offset)
 {
   VertexListType verticesList;
 
   if (isControlPoint)
   {
     verticesList = this->GetControlVertexList();
   }
   else
   {
     verticesList = *this->GetVertexList();
   }
 
   int vertexIndex = BruteForceGetVertexIndexAt(point, eps, verticesList, isControlPoint);
 
   if (vertexIndex!=-1)
   {
-    return verticesList[vertexIndex];
-  }
-  return nullptr;
-}
-
-mitk::ContourElement::VertexType *mitk::ContourElement::BruteForceGetNextVertexAt(const mitk::Point3D &point,
-                                                                              double eps,
-                                                                              bool isControlPoint)
-{
-  VertexListType verticesList;
-
-  if (isControlPoint)
-  {
-    verticesList = this->GetControlVertexList();
-  }
-  else
-  {
-    verticesList = *this->GetVertexList();
-  }
+    vertexIndex += offset;
+    auto size = (int) verticesList.size();
 
-  int vertexIndex = BruteForceGetVertexIndexAt(point, eps, verticesList, isControlPoint);
-
-  if (vertexIndex != -1)
-  {
-    vertexIndex++;
-    return verticesList[vertexIndex];
-  }
-  return nullptr;
-}
-
-mitk::ContourElement::VertexType *mitk::ContourElement::BruteForceGetPreviousVertexAt(const mitk::Point3D &point,
-                                                                                  double eps,
-                                                                                  bool isControlPoint)
-{
-  VertexListType verticesList;
-
-  if (isControlPoint)
-  {
-    verticesList = this->GetControlVertexList();
-  }
-  else
-  {
-    verticesList = *this->GetVertexList();
-  }
-
-  int vertexIndex = BruteForceGetVertexIndexAt(point, eps, verticesList, isControlPoint);
+    if (vertexIndex < 0)
+    {
+      // for negative offset
+      vertexIndex = verticesList.size() + offset;
+    }
+    else if (vertexIndex >= verticesList.size())
+    {
+      vertexIndex = vertexIndex - verticesList.size();
+    }
 
-  if (vertexIndex != -1)
-  {
-    vertexIndex--;
     return verticesList[vertexIndex];
   }
   return nullptr;
 }
 
 int mitk::ContourElement::BruteForceGetVertexIndexAt(const mitk::Point3D &point,
                                                      double eps,
                                                      VertexListType verticesList,
                                                      bool isControlPoint)
 {
   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 960e971a5f..85047a36de 100644
--- a/Modules/ContourModel/DataManagement/mitkContourElement.h
+++ b/Modules/ContourModel/DataManagement/mitkContourElement.h
@@ -1,282 +1,281 @@
 /*============================================================================
 
 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);
-    VertexType *BruteForceGetNextVertexAt(const mitk::Point3D &point, double eps, bool isControlPoint = false);
-    VertexType *BruteForceGetPreviousVertexAt(const mitk::Point3D &point, double eps, bool isControlPoint = false);
+    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);
 
     /** 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_
diff --git a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
index 1e61ffdb50..187be33ce4 100644
--- a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
+++ b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
@@ -1,524 +1,541 @@
 /*============================================================================
 
 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 "mitkContourModelLiveWireInteractor.h"
 
 #include "mitkInteractionPositionEvent.h"
 #include "mitkToolManager.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 
 #include <mitkInteractionConst.h>
 
 #include "mitkIOUtil.h"
 
 mitk::ContourModelLiveWireInteractor::ContourModelLiveWireInteractor() : ContourModelInteractor()
 {
   m_LiveWireFilter = mitk::ImageLiveWireContourModelFilter::New();
   m_LiveWireFilter->SetUseCostFunction(true);
   m_NextActiveVertexDown.Fill(0);
   m_NextActiveVertexUp.Fill(0);
 }
 
 mitk::ContourModelLiveWireInteractor::~ContourModelLiveWireInteractor()
 {
 }
 
 void mitk::ContourModelLiveWireInteractor::ConnectActionsAndFunctions()
 {
   CONNECT_CONDITION("checkisOverPoint", OnCheckPointClick);
   CONNECT_CONDITION("mouseMove", IsHovering);
 
   CONNECT_FUNCTION("movePoint", OnMovePoint);
   CONNECT_FUNCTION("deletePoint", OnDeletePoint);
   CONNECT_FUNCTION("finish", OnFinishEditing);
 }
 
 bool mitk::ContourModelLiveWireInteractor::OnCheckPointClick(const InteractionEvent *interactionEvent)
 {
   const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
 
   if (!positionEvent)
     return false;
 
   const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
 
   auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
   if (contour == nullptr)
   {
     MITK_ERROR << "Invalid Contour";
     return false;
   }
 
   contour->Deselect();
 
   // Check distance to any vertex.
   // Transition YES if click close to a vertex
   mitk::Point3D click = positionEvent->GetPositionInWorld();
 
   bool isVertexSelected = false;
   // Check, if clicked position is close to control vertex and if so, select closest control vertex.
   isVertexSelected = contour->SelectControlVertexAt(click, mitk::ContourModelLiveWireInteractor::eps, timeStep);
 
   // If the position is not close to control vertex. but hovering the contour line, we check, if it is close to non-control vertex.
   // The closest vertex will be set as a control vertex.
   if (isVertexSelected == false)
     isVertexSelected = contour->SelectVertexAt(click, mitk::ContourModelLiveWireInteractor::eps, timeStep);
 
    //  If the position is not close to control or non-control vertex. but hovering the contour line, we create a vertex at the position.
   if (isVertexSelected == false)
   {
     bool isHover = false;
     if (this->GetDataNode()->GetBoolProperty("contour.hovering", isHover, positionEvent->GetSender()) == false)
     {
       MITK_WARN << "Unknown property contour.hovering";
     }
     if (isHover)
     {
       contour->AddVertex(click, timeStep);
       isVertexSelected = contour->SelectVertexAt(click, mitk::ContourModelLiveWireInteractor::eps, timeStep);
     }
   }
 
   if (isVertexSelected)
   {
     contour->SetSelectedVertexAsControlPoint(true);
     auto controlVertices = contour->GetControlVertexList(timeStep);
     const mitk::ContourModel::VertexType *nextPoint = contour->GetNextVertexAt(click, mitk::ContourModelLiveWireInteractor::eps, timeStep);
     const mitk::ContourModel::VertexType *previousPoint = contour->GetPreviousVertexAt(click, mitk::ContourModelLiveWireInteractor::eps, timeStep);
     this->SplitContourFromSelectedVertex(contour, nextPoint, previousPoint, timeStep);
     m_NextActiveVertexUp = nextPoint->Coordinates;
     m_NextActiveVertexDown = previousPoint->Coordinates;
 
     // clear container with void points between neighboring control points
     m_ContourBeingModified.clear();
 
     // finally, return true to pass this condition
     return true;
   }
   else
   {
     // do not pass condition
     return false;
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
   return true;
 }
 
 void mitk::ContourModelLiveWireInteractor::SetEditingContourModelNode(mitk::DataNode *_arg)
 {
   if (this->m_EditingContourNode != _arg)
   {
     this->m_EditingContourNode = _arg;
   }
 }
 
 void mitk::ContourModelLiveWireInteractor::SetWorkingImage(mitk::Image *_arg)
 {
   if (this->m_WorkingSlice != _arg)
   {
     this->m_WorkingSlice = _arg;
     this->m_LiveWireFilter->SetInput(this->m_WorkingSlice);
   }
 }
 
 void mitk::ContourModelLiveWireInteractor::OnDeletePoint(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
 
   auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
   if (contour == nullptr)
   {
     MITK_ERROR << "Invalid Contour!";
     return;
   }
 
   if (contour->GetSelectedVertex())
   {
     mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
     newContour->Expand(contour->GetTimeSteps());
     newContour->SetTimeGeometry(contour->GetTimeGeometry()->Clone());
 
     newContour->Concatenate(m_ContourLeft, timeStep);
 
     // recompute contour between neighbored two active control points
     this->m_LiveWireFilter->SetStartPoint(this->m_NextActiveVertexDown);
     this->m_LiveWireFilter->SetEndPoint(this->m_NextActiveVertexUp);
     // this->m_LiveWireFilter->ClearRepulsivePoints();
     this->m_LiveWireFilter->Update();
 
     mitk::ContourModel *liveWireContour = this->m_LiveWireFilter->GetOutput();
     assert(liveWireContour);
 
     if (liveWireContour->IsEmpty(timeStep))
       return;
 
     liveWireContour->RemoveVertexAt(0, timeStep);
     liveWireContour->RemoveVertexAt(liveWireContour->GetNumberOfVertices(timeStep) - 1, timeStep);
 
     // insert new live wire computed points
     newContour->Concatenate(liveWireContour, timeStep);
 
     // insert right side of original contour
     newContour->Concatenate(this->m_ContourRight, timeStep);
 
     newContour->SetClosed(contour->IsClosed(timeStep), timeStep);
 
     // instead of leaving a single point, delete all points
     if (newContour->GetNumberOfVertices(timeStep) <= 2)
     {
       newContour->Clear(timeStep);
     }
 
     this->GetDataNode()->SetData(newContour);
 
     mitk::RenderingManager::GetInstance()->RequestUpdate(interactionEvent->GetSender()->GetRenderWindow());
   }
 }
 
 void mitk::ContourModelLiveWireInteractor::OnMovePoint(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
   if (!positionEvent)
     return;
 
   const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
   mitk::Point3D currentPosition = positionEvent->GetPositionInWorld();
 
   auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
   if (contour == nullptr)
   {
     MITK_ERROR << "invalid contour";
     return;
   }
 
   mitk::ContourModel::Pointer editingContour = mitk::ContourModel::New();
   editingContour->Expand(contour->GetTimeSteps());
   editingContour->SetTimeGeometry(contour->GetTimeGeometry()->Clone());
 
   // recompute left live wire, i.e. the contour between previous active vertex and selected vertex
   this->m_LiveWireFilter->SetStartPoint(this->m_NextActiveVertexDown);
   this->m_LiveWireFilter->SetEndPoint(currentPosition);
 
   // remove void positions between previous active vertex and next active vertex.
   if (!m_ContourBeingModified.empty())
   {
     std::vector<itk::Index<2>>::const_iterator iter = m_ContourBeingModified.begin();
     for (; iter != m_ContourBeingModified.end(); iter++)
     {
       this->m_LiveWireFilter->RemoveRepulsivePoint((*iter));
     }
   }
 
   // update to get the left livewire. Remember that the points in the rest of the contour are already
   // set as void positions in the filter
   this->m_LiveWireFilter->Update();
 
   mitk::ContourModel::Pointer leftLiveWire = this->m_LiveWireFilter->GetOutput();
   assert(leftLiveWire);
 
   if (!leftLiveWire->IsEmpty(timeStep))
     leftLiveWire->RemoveVertexAt(0, timeStep);
 
   editingContour->Concatenate(leftLiveWire, timeStep);
 
   // the new index of the selected vertex
   unsigned int selectedVertexIndex =
     this->m_ContourLeft->GetNumberOfVertices(timeStep) + leftLiveWire->GetNumberOfVertices(timeStep) - 1;
 
   // at this point the container has to be empty
   m_ContourBeingModified.clear();
 
   // add points from left live wire contour
   auto iter = leftLiveWire->IteratorBegin(timeStep);
   for (; iter != leftLiveWire->IteratorEnd(timeStep); iter++)
   {
     itk::Index<2> idx;
     this->m_WorkingSlice->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
     this->m_LiveWireFilter->AddRepulsivePoint(idx);
 
     // add indices
     m_ContourBeingModified.push_back(idx);
   }
 
   // recompute right live wire, i.e. the contour between selected vertex and next active vertex
   this->m_LiveWireFilter->SetStartPoint(currentPosition);
   this->m_LiveWireFilter->SetEndPoint(m_NextActiveVertexUp);
 
   // update filter with all contour points set as void but the right live wire portion to be calculated now
   this->m_LiveWireFilter->Update();
 
   mitk::ContourModel::Pointer rightLiveWire = this->m_LiveWireFilter->GetOutput();
   assert(rightLiveWire);
 
   // reject strange paths
   if (abs(rightLiveWire->GetNumberOfVertices(timeStep) - leftLiveWire->GetNumberOfVertices(timeStep)) > 50)
   {
     return;
   }
 
   if (!leftLiveWire->IsEmpty(timeStep))
     leftLiveWire->SetControlVertexAt(leftLiveWire->GetNumberOfVertices() - 1, timeStep);
 
   if (!rightLiveWire->IsEmpty(timeStep))
     rightLiveWire->RemoveVertexAt(0, timeStep);
 
   editingContour->Concatenate(rightLiveWire, timeStep);
 
   m_EditingContourNode->SetData(editingContour);
 
   mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
   newContour->Expand(contour->GetTimeSteps());
   newContour->SetTimeGeometry(contour->GetTimeGeometry()->Clone());
 
   // concatenate left original contour
   newContour->Concatenate(this->m_ContourLeft, timeStep);
 
   newContour->Concatenate(editingContour, timeStep, true);
 
   // set last inserted vertex as selected
   newContour->SelectVertexAt(selectedVertexIndex, timeStep);
 
   // set as control point
   newContour->SetSelectedVertexAsControlPoint(true);
 
   // concatenate right original contour
   newContour->Concatenate(this->m_ContourRight, timeStep);
 
   newContour->SetClosed(contour->IsClosed(timeStep), timeStep);
   this->GetDataNode()->SetData(newContour);
 
   mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 }
 
 bool mitk::ContourModelLiveWireInteractor::IsHovering(const InteractionEvent *interactionEvent)
 {
   const auto *positionEvent = dynamic_cast<const InteractionPositionEvent *>(interactionEvent);
   if (!positionEvent)
     return false;
 
   const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
 
   auto *contour = dynamic_cast<mitk::ContourModel *>(this->GetDataNode()->GetData());
 
   mitk::Point3D currentPosition = positionEvent->GetPositionInWorld();
 
   bool isHover = false;
   this->GetDataNode()->GetBoolProperty("contour.hovering", isHover, positionEvent->GetSender());
   if (contour->IsNearContour(currentPosition, mitk::ContourModelLiveWireInteractor::eps, timeStep))
   {
     if (isHover == false)
     {
       this->GetDataNode()->SetBoolProperty("contour.hovering", true);
       mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
     }
     return true;
   }
   else
   {
     if (isHover == true)
     {
       this->GetDataNode()->SetBoolProperty("contour.hovering", false);
       mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
     }
   }
   return false;
 }
 
 int mitk::ContourModelLiveWireInteractor::SplitContourFromSelectedVertex(mitk::ContourModel *srcContour,
                                                                          mitk::ContourModel *destContour,
                                                                          bool fromSelectedUpwards,
                                                                          int timestep)
 {
   auto end = srcContour->IteratorEnd();
   auto begin = srcContour->IteratorBegin();
 
   // search next active control point to left and rigth and set as start and end point for filter
   auto itSelected = begin;
 
   // move iterator to position
   while ((*itSelected) != srcContour->GetSelectedVertex())
   {
     itSelected++;
   }
 
   // CASE search upwards for next control point
   if (fromSelectedUpwards)
   {
     auto itUp = itSelected;
 
     if (itUp != end)
     {
       itUp++; // step once up otherwise the loop breaks immediately
     }
 
     while (itUp != end && !((*itUp)->IsControlPoint))
     {
       itUp++;
     }
 
     auto it = itUp;
 
     if (itSelected != begin)
     {
       // copy the rest of the original contour
       while (it != end)
       {
         destContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timestep);
         it++;
       }
     }
     // else do not copy the contour
 
     // return the offset of iterator at one before next-vertex-upwards
     if (itUp != begin)
     {
       return std::distance(begin, itUp) - 1;
     }
     else
     {
       return std::distance(begin, itUp);
     }
   }
   else // CASE search downwards for next control point
   {
     auto itDown = itSelected;
     auto it = srcContour->IteratorBegin();
 
     if (itSelected != begin)
     {
       if (itDown != begin)
       {
         itDown--; // step once down otherwise the the loop breaks immediately
       }
 
       while (itDown != begin && !((*itDown)->IsControlPoint))
       {
         itDown--;
       }
 
       if (it != end) // if not empty
       {
         // always add the first vertex
         destContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timestep);
         it++;
       }
       // copy from begin to itDown
       while (it <= itDown)
       {
         destContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timestep);
         it++;
       }
     }
     else
     {
       // if selected vertex is the first element search from end of contour downwards
       itDown = end;
       itDown--;
       while (!((*itDown)->IsControlPoint) && itDown != begin)
       {
         itDown--;
       }
 
       // move one forward as we don't want the first control point
       it++;
       // move iterator to second control point
       while ((it != end) && !((*it)->IsControlPoint))
       {
         it++;
       }
       // copy from begin to itDown
       while (it <= itDown)
       {
         // copy the contour from second control point to itDown
         destContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timestep);
         it++;
       }
     }
     /*
         //add vertex at itDown - it's not considered during while loop
         if( it != begin && it != end)
         {
           //destContour->AddVertex( (*it)->Coordinates, (*it)->IsControlPoint, timestep);
         }
     */
     // return the offset of iterator at one after next-vertex-downwards
     if (itDown != end)
     {
       return std::distance(begin, itDown); // + 1;//index of next vertex
     }
     else
     {
       return std::distance(begin, itDown) - 1;
     }
   }
 }
 
 void mitk::ContourModelLiveWireInteractor::SplitContourFromSelectedVertex(mitk::ContourModel *srcContour,
                                                                           const mitk::ContourModel::VertexType *nextPoint,
                                                                           const mitk::ContourModel::VertexType *previousPoint,
                                                                           int timeStep)
 {
   m_ContourLeft = mitk::ContourModel::New();
   m_ContourRight = mitk::ContourModel::New();
 
   auto it = srcContour->IteratorBegin();
   bool upperPart = false;
   bool lowerPart = true;
 
+  // edge cases when point right before first control vertex is selected or first control vertex is selected
+  if (nextPoint == (*it) || srcContour->GetSelectedVertex() == (*it))
+  {
+    upperPart = true;
+    lowerPart = false;
+    m_ContourLeft->AddVertex(previousPoint->Coordinates, previousPoint->IsControlPoint, timeStep);
+  }
+  // if first control vertex is selected, move to next point before adding vertices to m_ContourRight
+  // otherwise, second line appears when moving the vertex
+  if (srcContour->GetSelectedVertex() == (*it))
+  {
+    while (*it != nextPoint)
+    {
+      it++;
+    }
+  }
+
   // clear previous void positions
   this->m_LiveWireFilter->ClearRepulsivePoints();
 
   for (; it != srcContour->IteratorEnd(timeStep); it++)
   {
     if (lowerPart)
     {
       m_ContourLeft->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timeStep);
     }
 
     if (*it == previousPoint)
     {
       lowerPart = false;
       upperPart = false;
     }
 
     if (*it == nextPoint)
     {
       upperPart = true;
     }
 
     if (upperPart)
     {
       m_ContourRight->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timeStep);
     }
 
     if ((lowerPart && *it != previousPoint) || (upperPart && *it != nextPoint))
     {
       itk::Index<2> idx;
       this->m_WorkingSlice->GetGeometry()->WorldToIndex((*it)->Coordinates, idx);
       this->m_LiveWireFilter->AddRepulsivePoint(idx);
     }
   }
 }
 
 void mitk::ContourModelLiveWireInteractor::OnFinishEditing(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   const auto timeStep = interactionEvent->GetSender()->GetTimeStep(GetDataNode()->GetData());
 
   auto *editingContour = dynamic_cast<mitk::ContourModel *>(this->m_EditingContourNode->GetData());
 
   editingContour->Clear(timeStep);
 
   mitk::RenderingManager::GetInstance()->RequestUpdate(interactionEvent->GetSender()->GetRenderWindow());
 }