diff --git a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
index 28394b9a5d..cac0698b73 100644
--- a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
+++ b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.cpp
@@ -1,472 +1,483 @@
 /*===================================================================
 
 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 "mitkContourModelLiveWireInteractor.h"
 
 #include "mitkToolManager.h"
 
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 
 #include <mitkPositionEvent.h>
 #include <mitkStateEvent.h>
 
 #include <mitkInteractionConst.h>
 
 #include "mitkIOUtil.h"
 
 mitk::ContourModelLiveWireInteractor::ContourModelLiveWireInteractor(DataNode* dataNode)
 :ContourModelInteractor(dataNode)
 {
   CONNECT_ACTION( AcCLEAR, OnDumpImage ); // auxiliar for debug
   m_LiveWireFilter = mitk::ImageLiveWireContourModelFilter::New();
 
   m_NextActiveVertexDown.Fill(0);
   m_NextActiveVertexUp.Fill(0);
 }
 
 mitk::ContourModelLiveWireInteractor::~ContourModelLiveWireInteractor()
 {
 }
 
 bool mitk::ContourModelLiveWireInteractor::OnCheckPointClick( Action* action, const StateEvent* stateEvent)
 {
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
 
   if (!positionEvent)
   {
     this->HandleEvent( new mitk::StateEvent(EIDNO, stateEvent->GetEvent()) );
     return false;
   }
 
   mitk::StateEvent* newStateEvent = NULL;
 
   int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
 
   mitk::ContourModel *contour = dynamic_cast<mitk::ContourModel *>( m_DataNode->GetData() );
   assert ( contour );
 
   contour->Deselect();
 
   // Check distance to any vertex.
   // Transition YES if click close to a vertex
   mitk::Point3D click = positionEvent->GetWorldPosition();
 
   if (contour->SelectVertexAt(click, 1.5, timestep) )
   {
     contour->SetSelectedVertexAsControlPoint(false);
 
     m_lastMousePosition = click;
 
     m_ContourLeft = mitk::ContourModel::New();
 
     //get coordinates of next active vertex downwards from selected vertex
     int downIndex = this->SplitContourFromSelectedVertex( contour, m_ContourLeft, false, timestep);
 
     m_NextActiveVertexDownIter = contour->IteratorBegin() + downIndex;
     m_NextActiveVertexDown = (*m_NextActiveVertexDownIter)->Coordinates;
 
     m_ContourRight = mitk::ContourModel::New();
 
     //get coordinates of next active vertex upwards from selected vertex
     int upIndex = this->SplitContourFromSelectedVertex( contour, m_ContourRight, true, timestep);
 
     m_NextActiveVertexUpIter = contour->IteratorBegin() + upIndex;
     m_NextActiveVertexUp = (*m_NextActiveVertexUpIter)->Coordinates;
 
     // clear previous void positions
     this->m_LiveWireFilter->ClearRepulsivePoints();
 
     // set the current contour as void positions in the cost map
     // start with down side
     mitk::ContourModel::VertexIterator iter = contour->IteratorBegin(timestep);
     for (;iter != m_NextActiveVertexDownIter; iter++)
     {
       itk::Index<2> idx;
       this->m_WorkingSlice->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
       this->m_LiveWireFilter->AddRepulsivePoint( idx );
     }
 
     // continue with upper side
     iter = m_NextActiveVertexUpIter + 1;
     for (;iter != contour->IteratorEnd(timestep); iter++)
     {
       itk::Index<2> idx;
       this->m_WorkingSlice->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
       this->m_LiveWireFilter->AddRepulsivePoint( idx );
     }
 
     // clear container with void points between neighboring control points
     m_ContourBeingModified.clear();
 
     // let us have the selected point as a control point
     contour->SetSelectedVertexAsControlPoint(true);
 
     // finally, allow to leave current state
     newStateEvent = new mitk::StateEvent(EIDYES, stateEvent->GetEvent());
   }
   else
   {
     // do not allow to leave current state
     newStateEvent = new mitk::StateEvent(EIDNO, stateEvent->GetEvent());
   }
 
   this->HandleEvent( newStateEvent );
 
   assert( positionEvent->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   return true;
 }
 
 void mitk::ContourModelLiveWireInteractor::SetWorkingImage (mitk::Image* _arg)
 {
   if (this->m_WorkingSlice != _arg)
   {
     this->m_WorkingSlice = _arg;
     this->m_LiveWireFilter->SetInput(this->m_WorkingSlice);
     this->Modified();
   }
 }
 
+// delete me
+
 bool mitk::ContourModelLiveWireInteractor::OnDumpImage( Action* action, const StateEvent* stateEvent)
 {
     this->m_LiveWireFilter->DumpMaskImage();
     mitk::IOUtil::SaveImage(this->m_WorkingSlice, "G:\\Data\\slice.nrrd");
 
     return true;
 }
 
 bool mitk::ContourModelLiveWireInteractor::OnDeletePoint( Action* action, const StateEvent* stateEvent)
 {
 
   int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
 
   mitk::ContourModel *contour = dynamic_cast<mitk::ContourModel *>( m_DataNode->GetData() );
   assert ( contour );
 
   if (contour->GetSelectedVertex())
   {
 
     mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
     newContour->Expand(contour->GetTimeSteps());
 
     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 false;
 
     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->SetIsClosed(contour->IsClosed(timestep), timestep);
 
     m_DataNode->SetData(newContour);
 
     assert( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
     mitk::RenderingManager::GetInstance()->RequestUpdate( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
 
     return true;
   }
   return false;
 }
 
 bool mitk::ContourModelLiveWireInteractor::OnMovePoint( Action* action, const StateEvent* stateEvent)
 {
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
   mitk::Point3D currentPosition = positionEvent->GetWorldPosition();
 
   mitk::ContourModel *contour = dynamic_cast<mitk::ContourModel *>( m_DataNode->GetData() );
   assert ( contour );
 
   // 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->GetNumberOfVertices(timestep) > 1.5*m_EditingSize )
  //     return false;
 
   if ( !leftLiveWire->IsEmpty(timestep) )
     leftLiveWire->RemoveVertexAt(0, timestep);
 
   // at this point the container has to be empty
   m_ContourBeingModified.clear();
 
   // add points from left live wire contour
   mitk::ContourModel::VertexIterator 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 )
   {
       MITK_INFO << "reject strange path";
       return false;
   }
 */
+  if ( !leftLiveWire->IsEmpty(timestep) )
+    leftLiveWire->SetControlVertexAt(leftLiveWire->GetNumberOfVertices()-1, timestep);
+
   if ( !rightLiveWire->IsEmpty(timestep) )
     rightLiveWire->RemoveVertexAt(0, timestep);
 
-  if ( !leftLiveWire->IsEmpty(timestep) )
-    leftLiveWire->SetControlVertexAt(leftLiveWire->GetNumberOfVertices()-1, timestep);
 
   // set corrected left live wire to its node
-  m_LeftLiveWireContourNode->SetData(leftLiveWire);
+ // m_EditingContourNode->SetData(leftLiveWire);
 
   // set corrected right live wire to its node
-  m_RightLiveWireContourNode->SetData(rightLiveWire);
+ // m_RightLiveWireContourNode->SetData(rightLiveWire);
 
 // not really needed
 /*
   // add points from right live wire contour
   iter = rightLiveWire->IteratorBegin(timestep);
   for (;iter != rightLiveWire->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);
   }
 */
 
+  mitk::ContourModel::Pointer editingContour = mitk::ContourModel::New();
+  editingContour->Expand(contour->GetTimeSteps());
+
+  editingContour->Concatenate( leftLiveWire, timestep );
+  editingContour->Concatenate( rightLiveWire, timestep );
+
+  m_EditingContourNode->SetData(editingContour);
+
   mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
   newContour->Expand(contour->GetTimeSteps());
 
   // concatenate left original contour
   newContour->Concatenate( this->m_ContourLeft, timestep );
   newContour->Deselect();
 
   // concatenate left live wire but only if we have more than one vertex
   if (leftLiveWire->GetNumberOfVertices(timestep)>1)
       newContour->Concatenate( leftLiveWire, timestep );
 
   // set last inserted vertex as selected
   newContour->SelectVertexAt(newContour->GetNumberOfVertices()-1, timestep);
 
   // concatenate right live wire but only if we have more than one vertex
   if (rightLiveWire->GetNumberOfVertices(timestep)>1)
       newContour->Concatenate( rightLiveWire, timestep );
 
   // concatenate right original contour
   newContour->Concatenate( this->m_ContourRight, timestep );
 
   newContour->SetIsClosed(contour->IsClosed(timestep), timestep);
 
   m_DataNode->SetData(newContour);
 
   this->m_lastMousePosition = positionEvent->GetWorldPosition();
 
   assert( positionEvent->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   return true;
 }
 
 int mitk::ContourModelLiveWireInteractor::SplitContourFromSelectedVertex(mitk::ContourModel* srcContour,
                                                                          mitk::ContourModel* destContour,
                                                                          bool fromSelectedUpwards, int timestep)
 {
 
   mitk::ContourModel::VertexIterator end = srcContour->IteratorEnd();
   mitk::ContourModel::VertexIterator begin = srcContour->IteratorBegin();
 
   //search next active control point to left and rigth and set as start and end point for filter
   mitk::ContourModel::VertexIterator itSelected = begin;
 
   // move iterator to position
   while ((*itSelected) != srcContour->GetSelectedVertex())
   {
     itSelected++;
   }
 
   // CASE search upwards for next control point
   if(fromSelectedUpwards)
   {
     mitk::ContourModel::VertexIterator itUp = itSelected;
 
     if(itUp != end)
     {
       itUp++;//step once up otherwise the loop breaks immediately
     }
 
     while( itUp != end && !((*itUp)->IsControlPoint))
     {
         itUp++;
     }
 
     mitk::ContourModel::VertexIterator 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
   {
     mitk::ContourModel::VertexIterator itDown = itSelected;
     mitk::ContourModel::VertexIterator 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--;}
 
       //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;
     }
   }
 }
 
 
 bool mitk::ContourModelLiveWireInteractor::OnFinishEditing( Action* action, const StateEvent* stateEvent)
 {
   int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
 
-  mitk::ContourModel *leftLiveWire = dynamic_cast<mitk::ContourModel *>( this->m_LeftLiveWireContourNode->GetData() );
-  assert ( leftLiveWire );
-
-  leftLiveWire->Clear(timestep);
+  mitk::ContourModel *editingContour = dynamic_cast<mitk::ContourModel *>( this->m_EditingContourNode->GetData() );
+  assert ( editingContour );
 
+  editingContour->Clear(timestep);
+/*
   mitk::ContourModel *rightLiveWire = dynamic_cast<mitk::ContourModel *>( this->m_RightLiveWireContourNode->GetData() );
   assert ( rightLiveWire );
 
   rightLiveWire->Clear(timestep);
-
+*/
   assert( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
 
   return true;
 }
diff --git a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.h b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.h
index e2666a3993..53757b026f 100644
--- a/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.h
+++ b/Modules/Segmentation/Interactions/mitkContourModelLiveWireInteractor.h
@@ -1,99 +1,92 @@
 /*===================================================================
 
 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 mitkContourModelLiveWireInteractor_h_Included
 #define mitkContourModelLiveWireInteractor_h_Included
 
 #include "mitkCommon.h"
 #include "SegmentationExports.h"
 #include "mitkContourModelInteractor.h"
 
 #include <mitkImageLiveWireContourModelFilter.h>
 
 namespace mitk
 {
 
 
   /**
   \brief
 
   \sa Interactor
   \sa ContourModelInteractor
 
   \ingroup Interaction
 
 
   \warning Make sure the working image is properly set, otherwise the algorithm for computing livewire contour segments will not work!
 
   */
   class Segmentation_EXPORT ContourModelLiveWireInteractor : public ContourModelInteractor
   {
   public:
 
     mitkClassMacro(ContourModelLiveWireInteractor, ContourModelInteractor);
     mitkNewMacro1Param(Self, DataNode*);
 
-    virtual void SetLeftLiveWireContourModelNode (mitk::DataNode* _arg)
+    virtual void SetEditingContourModelNode (mitk::DataNode* _arg)
     {
-            this->m_LeftLiveWireContourNode = _arg;
-            this->Modified();
-    }
-
-    virtual void SetRightLiveWireContourModelNode (mitk::DataNode* _arg)
-    {
-            this->m_RightLiveWireContourNode = _arg;
+            this->m_EditingContourNode = _arg;
             this->Modified();
     }
 
     virtual void SetWorkingImage (mitk::Image* _arg);
 
   protected:
 
     ContourModelLiveWireInteractor(DataNode* dataNode);
     virtual ~ContourModelLiveWireInteractor();
 
     virtual bool OnDumpImage(Action*, const StateEvent*);
     virtual bool OnDeletePoint(Action*, const StateEvent*);
     virtual bool OnMovePoint(Action*, const StateEvent*);
     virtual bool OnCheckPointClick( Action* action, const StateEvent* stateEvent);
     virtual bool OnFinishEditing( Action* action, const StateEvent* stateEvent);
 
     int SplitContourFromSelectedVertex(mitk::ContourModel* srcContour,
                                        mitk::ContourModel* destContour,
                                        bool fromSelectedUpwards,
                                        int timestep);
 
     mitk::ImageLiveWireContourModelFilter::Pointer m_LiveWireFilter;
     mitk::Image::Pointer m_WorkingSlice;
 
     mitk::Point3D m_NextActiveVertexDown;
     mitk::Point3D m_NextActiveVertexUp;
 
     mitk::ContourModel::VertexIterator m_NextActiveVertexDownIter;
     mitk::ContourModel::VertexIterator m_NextActiveVertexUpIter;
 
     std::vector < itk::Index<2> > m_ContourBeingModified;
 
-    mitk::DataNode::Pointer m_LeftLiveWireContourNode;
-    mitk::DataNode::Pointer m_RightLiveWireContourNode;
+    mitk::DataNode::Pointer m_EditingContourNode;
     mitk::ContourModel::Pointer m_ContourLeft;
     mitk::ContourModel::Pointer m_ContourRight;
 
   };
 
 } // namespace mitk
 
 #endif // mitkContourModelLiveWireInteractor_h_Included
diff --git a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
index fef9e536bf..bcca9cf8b4 100644
--- a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
@@ -1,633 +1,617 @@
 /*===================================================================
 
 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 "mitkLiveWireTool2D.h"
 
 #include "mitkToolManager.h"
 #include "mitkBaseRenderer.h"
 #include "mitkRenderingManager.h"
 
 #include "mitkLiveWireTool2D.xpm"
 
 #include <mitkInteractionConst.h>
 #include <mitkGlobalInteraction.h>
 
 #include "mitkContourUtils.h"
 #include "mitkContour.h"
 
 #include <itkGradientMagnitudeImageFilter.h>
 
 
 namespace mitk {
   MITK_TOOL_MACRO(Segmentation_EXPORT, LiveWireTool2D, "LiveWire tool");
 }
 
 
 mitk::LiveWireTool2D::LiveWireTool2D()
 :SegTool2D("LiveWireTool")
 {
 
   // great magic numbers
   CONNECT_ACTION( AcINITNEWOBJECT, OnInitLiveWire );
   CONNECT_ACTION( AcADDPOINT, OnAddPoint );
   CONNECT_ACTION( AcMOVE, OnMouseMoveNoDynamicCosts );
   CONNECT_ACTION( AcCHECKPOINT, OnCheckPoint );
   CONNECT_ACTION( AcFINISH, OnFinish );
   CONNECT_ACTION( AcDELETEPOINT, OnLastSegmentDelete );
   CONNECT_ACTION( AcADDLINE, OnMouseMoved );
 }
 
 
 
 mitk::LiveWireTool2D::~LiveWireTool2D()
 {
   m_Contours.clear();
 }
 
 
 
 float mitk::LiveWireTool2D::CanHandleEvent( StateEvent const *stateEvent) const
 {
   mitk::PositionEvent const  *positionEvent =
   dynamic_cast <const mitk::PositionEvent *> (stateEvent->GetEvent());
 
   //Key event handling:
   if (positionEvent == NULL)
   {
     //check for delete and escape event
     if(stateEvent->GetId() == 12 || stateEvent->GetId() == 14)
     {
       return 1.0;
     }
     //check, if the current state has a transition waiting for that key event.
     else if (this->GetCurrentState()->GetTransition(stateEvent->GetId())!=NULL)
     {
       return 0.5;
     }
     else
     {
       return 0.0;
     }
   }
   else
   {
     if ( positionEvent->GetSender()->GetMapperID() != BaseRenderer::Standard2D )
       return 0.0; // we don't want anything but 2D
 
     return 1.0;
   }
 
 }
 
 
 
 
 const char** mitk::LiveWireTool2D::GetXPM() const
 {
   return mitkLiveWireTool2D_xpm;
 }
 
 
 
 
 const char* mitk::LiveWireTool2D::GetName() const
 {
   return "LiveWire";
 }
 
 
 
 
 void mitk::LiveWireTool2D::Activated()
 {
   Superclass::Activated();
 }
 
 
 
 
 void mitk::LiveWireTool2D::Deactivated()
 {
  // this->FinishTool();
 
   //add interactor to globalInteraction instance
   mitk::GlobalInteraction::GetInstance()->RemoveInteractor(m_LiveWireInteractor);
 
   DataNode* workingNode( m_ToolManager->GetWorkingData(0) );
   if ( !workingNode ) return;
 
   Image* workingImage = dynamic_cast<Image*>(workingNode->GetData());
   if ( !workingImage ) return;
 
   ContourUtils::Pointer contourUtils = mitk::ContourUtils::New();
 
   // for all contours in list (currently created by tool)
   std::vector< std::pair<mitk::DataNode*, mitk::PlaneGeometry::Pointer> >::iterator it = m_Contours.begin();
   while(it != m_Contours.end() )
   {
 
     // if node contains data
     if( it->first->GetData() )
     {
 
       // if this is a contourModel
       mitk::ContourModel* contourModel = dynamic_cast<mitk::ContourModel*>(it->first->GetData());
       if( contourModel )
       {
 
         //++++++++++++++++++++++ for each timestep of this contourModel
         for( int currentTimestep = 0; currentTimestep < contourModel->GetTimeSlicedGeometry()->GetTimeSteps(); currentTimestep++)
         {
 
           //get the segmentation image slice at current timestep
           mitk::Image::Pointer workingSlice = this->GetAffectedImageSliceAs2DImage(it->second, workingImage, currentTimestep);
 
           // transfer to plain old contour to use contour util functionality
           mitk::Contour::Pointer plainOldContour = mitk::Contour::New();
           mitk::ContourModel::VertexIterator iter = contourModel->IteratorBegin(currentTimestep);
           while(iter != contourModel->IteratorEnd(currentTimestep) )
           {
             plainOldContour->AddVertex( (*iter)->Coordinates );
             iter++;
           }
 
           mitk::Contour::Pointer projectedContour = contourUtils->ProjectContourTo2DSlice(workingSlice, plainOldContour, true, false);
           contourUtils->FillContourInSlice(projectedContour, workingSlice, 1.0);
 
           //write back to image volume
           this->WriteBackSegmentationResult(it->second, workingSlice, currentTimestep);
         }
 
         //remove contour node from datastorage
         m_ToolManager->GetDataStorage()->Remove( it->first );
       }
     }
 
     ++it;
   }
 
   m_Contours.clear();
 
-  m_ToolManager->GetDataStorage()->Remove( m_LeftLiveWireContourNode );
-  m_ToolManager->GetDataStorage()->Remove( m_RightLiveWireContourNode );
+//  m_ToolManager->GetDataStorage()->Remove( m_LeftLiveWireContourNode );
+  m_ToolManager->GetDataStorage()->Remove( m_EditingContourNode );
 
-  m_LeftLiveWireContourNode = NULL;
-  m_LeftLiveWireContour = NULL;
+  m_EditingContourNode = NULL;
+  m_EditingContour = NULL;
 
-  m_RightLiveWireContourNode = NULL;
-  m_RightLiveWireContour = NULL;
+//  m_RightLiveWireContourNode = NULL;
+//  m_RightLiveWireContour = NULL;
 
   Superclass::Deactivated();
 }
 
 bool mitk::LiveWireTool2D::OnInitLiveWire (Action* action, const StateEvent* stateEvent)
 {
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
 
   if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
 
   int timestep = positionEvent->GetSender()->GetTimeStep();
 
   m_Contour = mitk::ContourModel::New();
   m_Contour->Expand(timestep+1);
   m_ContourModelNode = mitk::DataNode::New();
   m_ContourModelNode->SetData( m_Contour );
   m_ContourModelNode->SetName("working contour node");
   m_ContourModelNode->AddProperty( "contour.color", ColorProperty::New(1, 1, 0), NULL, true );
   m_ContourModelNode->AddProperty( "contour.points.color", ColorProperty::New(1.0, 0.0, 0.1), NULL, true );
   m_ContourModelNode->AddProperty( "contour.controlpoints.show", BoolProperty::New(true), NULL, true );
 
   m_LiveWireContour = mitk::ContourModel::New();
   m_LiveWireContour->Expand(timestep+1);
   m_LiveWireContourNode = mitk::DataNode::New();
   m_LiveWireContourNode->SetData( m_LiveWireContour );
   m_LiveWireContourNode->SetName("active livewire node");
   m_LiveWireContourNode->AddProperty( "contour.color", ColorProperty::New(0.1, 1.0, 0.1), NULL, true );
   m_LiveWireContourNode->AddProperty( "contour.width", mitk::FloatProperty::New( 4.0 ), NULL, true );
 
-  m_LeftLiveWireContour = mitk::ContourModel::New();
-  m_LeftLiveWireContour->Expand(timestep+1);
-  m_LeftLiveWireContourNode = mitk::DataNode::New();
-  m_LeftLiveWireContourNode->SetData( m_LeftLiveWireContour );
-  m_LeftLiveWireContourNode->SetName("left node");
-  m_LeftLiveWireContourNode->AddProperty( "contour.color", ColorProperty::New(0.1, 1.0, 0.1), NULL, true );
-  m_LeftLiveWireContourNode->AddProperty( "contour.points.color", ColorProperty::New(0.0, 0.0, 1.0), NULL, true );
-  m_LeftLiveWireContourNode->AddProperty( "contour.width", mitk::FloatProperty::New( 4.0 ), NULL, true );
-
-  m_RightLiveWireContour = mitk::ContourModel::New();
-  m_RightLiveWireContour->Expand(timestep+1);
-  m_RightLiveWireContourNode = mitk::DataNode::New();
-  m_RightLiveWireContourNode->SetData( m_RightLiveWireContour );
-  m_RightLiveWireContourNode->SetName("right node");
-  m_RightLiveWireContourNode->AddProperty( "contour.color", ColorProperty::New(0.1, 1.0, 0.1), NULL, true );
-  m_RightLiveWireContourNode->AddProperty( "contour.width", mitk::FloatProperty::New( 4.0 ), NULL, true );
+  m_EditingContour = mitk::ContourModel::New();
+  m_EditingContour->Expand(timestep+1);
+  m_EditingContourNode = mitk::DataNode::New();
+  m_EditingContourNode->SetData( m_EditingContour );
+  m_EditingContourNode->SetName("editing node");
+  m_EditingContourNode->AddProperty( "contour.color", ColorProperty::New(0.1, 1.0, 0.1), NULL, true );
+  m_EditingContourNode->AddProperty( "contour.points.color", ColorProperty::New(0.0, 0.0, 1.0), NULL, true );
+  m_EditingContourNode->AddProperty( "contour.width", mitk::FloatProperty::New( 4.0 ), NULL, true );
 
   m_ToolManager->GetDataStorage()->Add( m_ContourModelNode );
   m_ToolManager->GetDataStorage()->Add( m_LiveWireContourNode );
-  m_ToolManager->GetDataStorage()->Add( m_RightLiveWireContourNode );
-  m_ToolManager->GetDataStorage()->Add( m_LeftLiveWireContourNode );
+  m_ToolManager->GetDataStorage()->Add( m_EditingContourNode );
 
   //set current slice as input for ImageToLiveWireContourFilter
   m_WorkingSlice = this->GetAffectedReferenceSlice(positionEvent);
 
   m_LiveWireFilter = mitk::ImageLiveWireContourModelFilter::New();
   m_LiveWireFilter->SetInput(m_WorkingSlice);
 
   //map click to pixel coordinates
   mitk::Point3D click = const_cast<mitk::Point3D &>(positionEvent->GetWorldPosition());
   itk::Index<3> idx;
   m_WorkingSlice->GetGeometry()->WorldToIndex(click, idx);
 
   // get the pixel the gradient in region of 5x5
   itk::Index<3> indexWithHighestGradient;
   AccessFixedDimensionByItk_2(m_WorkingSlice, FindHighestGradientMagnitudeByITK, 2, idx, indexWithHighestGradient);
 
   // itk::Index to mitk::Point3D
   click[0] = indexWithHighestGradient[0];
   click[1] = indexWithHighestGradient[1];
   click[2] = indexWithHighestGradient[2];
   m_WorkingSlice->GetGeometry()->IndexToWorld(click, click);
 
   //set initial start point
   m_Contour->AddVertex( click, true, timestep );
   m_LiveWireFilter->SetStartPoint(click);
 
   m_CreateAndUseDynamicCosts = true;
 
   //render
   assert( positionEvent->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   return true;
 }
 
-
-
-
 bool mitk::LiveWireTool2D::OnAddPoint (Action* action, const StateEvent* stateEvent)
 {
   //complete LiveWire interaction for last segment
   //add current LiveWire contour to the finished contour and reset
   //to start new segment and computation
 
   /* check if event can be handled */
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
   /* END check if event can be handled */
 
   int timestep = positionEvent->GetSender()->GetTimeStep();
 
   typedef mitk::ImageLiveWireContourModelFilter::InternalImageType::IndexType IndexType;
   mitk::ContourModel::ConstVertexIterator iter = m_LiveWireContour->IteratorBegin(timestep);
   for (;iter != m_LiveWireContour->IteratorEnd(timestep); iter++)
   {
       IndexType idx;
       this->m_WorkingSlice->GetGeometry()->WorldToIndex((*iter)->Coordinates, idx);
 
       this->m_LiveWireFilter->AddRepulsivePoint( idx );
   }
 
   this->m_LiveWireFilter->Update();
 
   //remove duplicate first vertex, it's already contained in m_Contour
   m_LiveWireContour->RemoveVertexAt(0, timestep);
 
   // set last added point as control point
   m_LiveWireContour->SetControlVertexAt(m_LiveWireContour->GetNumberOfVertices(timestep)-1, timestep);
 
   //merge contours
   m_Contour->Concatenate(m_LiveWireContour, timestep);
 
   //clear the livewire contour and reset the corresponding datanode
   m_LiveWireContour->Clear(timestep);
 
   //set new start point
   m_LiveWireFilter->SetStartPoint(const_cast<mitk::Point3D &>(positionEvent->GetWorldPosition()));
 
   if( m_CreateAndUseDynamicCosts )
   {
     //use dynamic cost map for next update
     m_LiveWireFilter->CreateDynamicCostMap(m_Contour);
     m_LiveWireFilter->SetUseDynamicCostMap(true);
     //m_CreateAndUseDynamicCosts = false;
   }
 
   //render
   assert( positionEvent->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   return true;
 }
 
-
-
-
 bool mitk::LiveWireTool2D::OnMouseMoved( Action* action, const StateEvent* stateEvent)
 {
   //compute LiveWire segment from last control point to current mouse position
 
   // check if event can be handled
   if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
 
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   // actual LiveWire computation
   int timestep = positionEvent->GetSender()->GetTimeStep();
 
   m_LiveWireFilter->SetEndPoint(const_cast<mitk::Point3D &>(positionEvent->GetWorldPosition()));
 
   m_LiveWireFilter->SetTimeStep(m_TimeStep);
   m_LiveWireFilter->Update();
 
   m_LiveWireContour = this->m_LiveWireFilter->GetOutput();
   m_LiveWireContourNode->SetData( this->m_LiveWireContour );
 
   //render
   assert( positionEvent->GetSender()->GetRenderWindow() );
   mitk::RenderingManager::GetInstance()->RequestUpdate( positionEvent->GetSender()->GetRenderWindow() );
 
   return true;
 }
 
 bool mitk::LiveWireTool2D::OnMouseMoveNoDynamicCosts(Action* action, const StateEvent* stateEvent)
 {
   //do not use dynamic cost map
   m_LiveWireFilter->SetUseDynamicCostMap(false);
   OnMouseMoved(action, stateEvent);
   m_LiveWireFilter->SetUseDynamicCostMap(true);
   return true;
 }
 
 bool mitk::LiveWireTool2D::OnCheckPoint( Action* action, const StateEvent* stateEvent)
 {
   //check double click on first control point to finish the LiveWire tool
   //
   //Check distance to first point.
   //Transition YES if click close to first control point
   //
 
   mitk::StateEvent* newStateEvent = NULL;
 
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent)
   {
     //stay in current state
     newStateEvent = new mitk::StateEvent(EIDNO, stateEvent->GetEvent());
   }
   else
   {
     int timestep = positionEvent->GetSender()->GetTimeStep();
 
     mitk::Point3D click = positionEvent->GetWorldPosition();
 
     mitk::Point3D first = this->m_Contour->GetVertexAt(0, timestep)->Coordinates;
 
     if (first.EuclideanDistanceTo(click) < 4.5)
     {
       // allow to finish
       newStateEvent = new mitk::StateEvent(EIDYES, stateEvent->GetEvent());
     }
     else
     {
       //stay active
       newStateEvent = new mitk::StateEvent(EIDNO, stateEvent->GetEvent());
     }
   }
 
   this->HandleEvent( newStateEvent );
 
   return true;
 }
 
 bool mitk::LiveWireTool2D::OnFinish( Action* action, const StateEvent* stateEvent)
 {
   // finish livewire tool interaction
 
   // check if event can be handled
   if ( Superclass::CanHandleEvent(stateEvent) < 1.0 ) return false;
 
   const PositionEvent* positionEvent = dynamic_cast<const PositionEvent*>(stateEvent->GetEvent());
   if (!positionEvent) return false;
 
   // actual timestep
   int timestep = positionEvent->GetSender()->GetTimeStep();
 
   // remove last control point being added by double click
   m_Contour->RemoveVertexAt(m_Contour->GetNumberOfVertices(timestep) - 1, timestep);
 
   // save contour and corresponding plane geometry to list
   std::pair<mitk::DataNode*, mitk::PlaneGeometry::Pointer> contourPair(m_ContourModelNode.GetPointer(), dynamic_cast<mitk::PlaneGeometry*>(positionEvent->GetSender()->GetCurrentWorldGeometry2D()->Clone().GetPointer()) );
   m_Contours.push_back(contourPair);
 
   m_LiveWireFilter->SetUseDynamicCostMap(false);
 
   this->FinishTool();
 
   return true;
 }
 
 void mitk::LiveWireTool2D::FinishTool()
 {
   unsigned int numberOfTimesteps = m_Contour->GetTimeSlicedGeometry()->GetTimeSteps();
 
   //close contour in each timestep
   for( int i = 0; i <= numberOfTimesteps; i++)
   {
     m_Contour->Close(i);
   }
 
   m_ToolManager->GetDataStorage()->Remove( m_LiveWireContourNode );
 
   // clear live wire contour node
   m_LiveWireContourNode = NULL;
   m_LiveWireContour = NULL;
 
-  //TODO visual feedback for completing livewire tool
+  //change color as visual feedback of completed livewire
   m_ContourModelNode->AddProperty( "contour.color", ColorProperty::New(1.0, 1.0, 0.1), NULL, true );
   m_ContourModelNode->SetName("contour node");
 
   //set the livewire interactor to edit control points
   m_LiveWireInteractor = mitk::ContourModelLiveWireInteractor::New(m_ContourModelNode);
   m_LiveWireInteractor->SetWorkingImage(this->m_WorkingSlice);
-  m_LiveWireInteractor->SetRightLiveWireContourModelNode(this->m_RightLiveWireContourNode);
-  m_LiveWireInteractor->SetLeftLiveWireContourModelNode(this->m_LeftLiveWireContourNode);
+  m_LiveWireInteractor->SetEditingContourModelNode(this->m_EditingContourNode);
   m_ContourModelNode->SetInteractor(m_LiveWireInteractor);
 
   //add interactor to globalInteraction instance
   mitk::GlobalInteraction::GetInstance()->AddInteractor(m_LiveWireInteractor);
 }
 
 bool mitk::LiveWireTool2D::OnLastSegmentDelete( Action* action, const StateEvent* stateEvent)
 {
   int timestep = stateEvent->GetEvent()->GetSender()->GetTimeStep();
 
   //if last point of current contour will be removed go to start state and remove nodes
   if( m_Contour->GetNumberOfVertices(timestep) <= 1 )
   {
     m_ToolManager->GetDataStorage()->Remove( m_LiveWireContourNode );
     m_ToolManager->GetDataStorage()->Remove( m_ContourModelNode );
     m_LiveWireContour = mitk::ContourModel::New();
     m_Contour = mitk::ContourModel::New();
     m_ContourModelNode->SetData( m_Contour );
     m_LiveWireContourNode->SetData( m_LiveWireContour );
     Superclass::Deactivated(); //go to start state
   }
   else //remove last segment from contour and reset livewire contour
   {
 
     m_LiveWireContour = mitk::ContourModel::New();
 
     m_LiveWireContourNode->SetData(m_LiveWireContour);
 
 
     mitk::ContourModel::Pointer newContour = mitk::ContourModel::New();
     newContour->Expand(m_Contour->GetTimeSteps());
 
     mitk::ContourModel::VertexIterator begin = m_Contour->IteratorBegin();
 
     //iterate from last point to next active point
     mitk::ContourModel::VertexIterator newLast = m_Contour->IteratorBegin() + (m_Contour->GetNumberOfVertices() - 1);
 
     //go at least one down
     if(newLast != begin)
     {
       newLast--;
     }
 
     //search next active control point
     while(newLast != begin && !((*newLast)->IsControlPoint) )
     {
       newLast--;
     }
 
     //set position of start point for livewire filter to coordinates of the new last point
     m_LiveWireFilter->SetStartPoint((*newLast)->Coordinates);
 
     mitk::ContourModel::VertexIterator it = m_Contour->IteratorBegin();
 
     //fill new Contour
     while(it <= newLast)
     {
       newContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint, timestep);
       it++;
     }
 
     newContour->SetIsClosed(m_Contour->IsClosed());
 
     //set new contour visible
     m_ContourModelNode->SetData(newContour);
 
     m_Contour = newContour;
 
     assert( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
     mitk::RenderingManager::GetInstance()->RequestUpdate( stateEvent->GetEvent()->GetSender()->GetRenderWindow() );
   }
 
   return true;
 }
 
 
 template<typename TPixel, unsigned int VImageDimension>
 void mitk::LiveWireTool2D::FindHighestGradientMagnitudeByITK(itk::Image<TPixel, VImageDimension>* inputImage, itk::Index<3> &index, itk::Index<3> &returnIndex)
 {
   typedef itk::Image<TPixel, VImageDimension>  InputImageType;
   typedef typename InputImageType::IndexType            IndexType;
 
   unsigned long xMAX = inputImage->GetLargestPossibleRegion().GetSize()[0];
   unsigned long yMAX = inputImage->GetLargestPossibleRegion().GetSize()[1];
 
   returnIndex[0] = index[0];
   returnIndex[1] = index[1];
   returnIndex[2] = 0.0;
 
 
   double gradientMagnitude = 0.0;
   double maxGradientMagnitude = 0.0;
 
   /*
     the size and thus the region of 7x7 is only used to calculate the gradient magnitude in that region
     not for searching the maximum value
     */
 
   //maximum value in each direction for size
   typename InputImageType::SizeType size;
   size[0] = 7;
   size[1] = 7;
 
   //minimum value in each direction for startRegion
   IndexType startRegion;
   startRegion[0] = index[0] - 3;
   startRegion[1] = index[1] - 3;
   if(startRegion[0] < 0) startRegion[0] = 0;
   if(startRegion[1] < 0) startRegion[1] = 0;
   if(xMAX - index[0] < 7) startRegion[0] = xMAX - 7;
   if(yMAX - index[1] < 7) startRegion[1] = yMAX - 7;
 
   index[0] = startRegion[0] + 3;
   index[1] = startRegion[1] + 3;
 
 
 
   typename InputImageType::RegionType region;
   region.SetSize( size );
   region.SetIndex( startRegion );
 
   typedef typename  itk::GradientMagnitudeImageFilter< InputImageType, InputImageType> GradientMagnitudeFilterType;
   typename GradientMagnitudeFilterType::Pointer gradientFilter = GradientMagnitudeFilterType::New();
   gradientFilter->SetInput(inputImage);
   gradientFilter->GetOutput()->SetRequestedRegion(region);
 
   gradientFilter->Update();
   typename InputImageType::Pointer gradientMagnImage;
   gradientMagnImage = gradientFilter->GetOutput();
 
 
   IndexType currentIndex;
   currentIndex[0] = 0;
   currentIndex[1] = 0;
 
   // search max (approximate) gradient magnitude
   for( int x = -1; x <= 1; ++x)
   {
     currentIndex[0] = index[0] + x;
 
     for( int y = -1; y <= 1; ++y)
     {
       currentIndex[1] = index[1] + y;
 
       gradientMagnitude = gradientMagnImage->GetPixel(currentIndex);
 
       //check for new max
       if(maxGradientMagnitude < gradientMagnitude)
       {
         maxGradientMagnitude = gradientMagnitude;
         returnIndex[0] = currentIndex[0];
         returnIndex[1] = currentIndex[1];
         returnIndex[2] = 0.0;
       }//end if
     }//end for y
 
     currentIndex[1] = index[1];
   }//end for x
 
 }
diff --git a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.h b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.h
index 84d7181639..3c1d630e17 100644
--- a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.h
+++ b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.h
@@ -1,127 +1,127 @@
 /*===================================================================
 
 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 mitkCorrectorTool2D_h_Included
 #define mitkCorrectorTool2D_h_Included
 
 #include "mitkCommon.h"
 #include "SegmentationExports.h"
 #include "mitkSegTool2D.h"
 #include <mitkContourModel.h>
 #include <mitkContourModelLiveWireInteractor.h>
 #include <mitkImageLiveWireContourModelFilter.h>
 
 namespace mitk
 {
 
 
 /**
   \brief A 2D segmentation tool based on LiveWire approach.
   The contour between the last user added point and the current mouse position
   is computed by searching the shortest path according to specific features of
   the image. The contour thus snappest to the boundary of objects.
 
 
   \sa SegTool2D
   \sa ImageLiveWireContourModelFilter
 
   \ingroup Interaction
   \ingroup ToolManagerEtAl
 
   \warning Only to be instantiated by mitk::ToolManager.
 */
 class Segmentation_EXPORT LiveWireTool2D : public SegTool2D
 {
   public:
 
     mitkClassMacro(LiveWireTool2D, SegTool2D);
     itkNewMacro(LiveWireTool2D);
 
     virtual const char** GetXPM() const;
     virtual const char* GetName() const;
 
   protected:
 
     LiveWireTool2D();
     virtual ~LiveWireTool2D();
 
     /**
     * \brief Calculates how good the data, this statemachine handles, is hit by the event.
     *
     */
     virtual float CanHandleEvent( StateEvent const *stateEvent) const;
 
     virtual void Activated();
     virtual void Deactivated();
 
     /// \brief Initialize tool
     virtual bool OnInitLiveWire (Action*, const StateEvent*);
 
     /// \brief Add a control point and finish current segment
     virtual bool OnAddPoint   (Action*, const StateEvent*);
 
     /// \breif Actual LiveWire computation
     virtual bool OnMouseMoved(Action*, const StateEvent*);
 
     /// \brief Check double click on first control point to finish the LiveWire tool
     virtual bool OnCheckPoint(Action*, const StateEvent*);
 
     /// \brief Finish LiveWire tool
     virtual bool OnFinish(Action*, const StateEvent*);
 
     /// \brief Close the contour
     virtual bool OnLastSegmentDelete(Action*, const StateEvent*);
 
     /// \brief Don't use dynamic cost map for LiveWire calculation
     virtual bool OnMouseMoveNoDynamicCosts(Action*, const StateEvent*);
 
     /// \brief Finish contour interaction.
     void FinishTool();
 
 
     //the contour already set by the user
     mitk::ContourModel::Pointer m_Contour;
     //the corresponding datanode
     mitk::DataNode::Pointer m_ContourModelNode;
 
     //the current LiveWire computed contour
     mitk::ContourModel::Pointer m_LiveWireContour;
-    mitk::ContourModel::Pointer m_RightLiveWireContour;
-    mitk::ContourModel::Pointer m_LeftLiveWireContour;
+    mitk::ContourModel::Pointer m_EditingContour;
+//    mitk::ContourModel::Pointer m_LeftLiveWireContour;
 
     //the corresponding datanode
     mitk::DataNode::Pointer m_LiveWireContourNode;
-    mitk::DataNode::Pointer m_LeftLiveWireContourNode;
-    mitk::DataNode::Pointer m_RightLiveWireContourNode;
+    mitk::DataNode::Pointer m_EditingContourNode;
+//    mitk::DataNode::Pointer m_RightLiveWireContourNode;
 
     mitk::ContourModelLiveWireInteractor::Pointer m_LiveWireInteractor;
 
     //the current reference image
     mitk::Image::Pointer m_WorkingSlice;
 
     mitk::ImageLiveWireContourModelFilter::Pointer m_LiveWireFilter;
 
     bool m_CreateAndUseDynamicCosts;
 
     std::vector< std::pair<mitk::DataNode*, mitk::PlaneGeometry::Pointer> > m_Contours;
 
     template<typename TPixel, unsigned int VImageDimension>
     void FindHighestGradientMagnitudeByITK(itk::Image<TPixel, VImageDimension>* inputImage, itk::Index<3> &index, itk::Index<3> &returnIndex);
 };
 
 } // namespace
 
 #endif