diff --git a/Modules/IOExt/Internal/mitkUnstructuredGridVtkWriter.txx b/Modules/IOExt/Internal/mitkUnstructuredGridVtkWriter.txx
index 3f44c734b9..9e3d6f9376 100644
--- a/Modules/IOExt/Internal/mitkUnstructuredGridVtkWriter.txx
+++ b/Modules/IOExt/Internal/mitkUnstructuredGridVtkWriter.txx
@@ -1,196 +1,196 @@
 /*============================================================================
 
 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 _MITK_UNSTRUCTURED_GRID_VTKWRITER_TXX_
 #define _MITK_UNSTRUCTURED_GRID_VTKWRITER_TXX_
 
 #include <itkLightObject.h>
 #include <vtkLinearTransform.h>
 #include <vtkTransformFilter.h>
 #include <vtkUnstructuredGrid.h>
 #include <vtkUnstructuredGridWriter.h>
 #include <vtkXMLPUnstructuredGridWriter.h>
 #include <vtkXMLUnstructuredGridWriter.h>
 
 #include <sstream>
 #include <cstdio>
 #include <sys/stat.h>
 #include <sys/types.h>
 
 namespace mitk
 {
   template <class VTKWRITER>
   UnstructuredGridVtkWriter<VTKWRITER>::UnstructuredGridVtkWriter() : m_Success(false)
   {
     this->SetNumberOfRequiredInputs(1);
   }
 
   template <class VTKWRITER>
   UnstructuredGridVtkWriter<VTKWRITER>::~UnstructuredGridVtkWriter()
   {
   }
 
   template <class VTKWRITER>
   void UnstructuredGridVtkWriter<VTKWRITER>::GenerateData()
   {
     m_Success = false;
     if (m_FileName == "")
     {
       itkWarningMacro(<< "Sorry, filename has not been set!");
       return;
     }
 
     mitk::UnstructuredGrid::Pointer input = const_cast<mitk::UnstructuredGrid *>(this->GetInput());
 
     if (input.IsNull())
     {
       itkWarningMacro(<< "Sorry, input to mitk::UnstructuredGridVtkWriter is NULL");
       return;
     }
 
     VTKWRITER *unstructuredGridWriter = VTKWRITER::New();
     vtkTransformFilter *transformPointSet = vtkTransformFilter::New();
     vtkUnstructuredGrid *unstructuredGrid;
     BaseGeometry *geometry;
 
     if (input->GetTimeGeometry()->CountTimeSteps() > 1)
     {
       int t, timesteps;
 
       timesteps = input->GetTimeGeometry()->CountTimeSteps();
       for (t = 0; t < timesteps; ++t)
       {
         std::ostringstream filename;
         geometry = input->GetGeometry(t);
         if (input->GetTimeGeometry()->IsValidTimeStep(t))
         {
-          const mitk::TimeBounds &timebounds = input->GetTimeGeometry()->GetTimeBounds(t);
+          const mitk::TimeBounds timebounds = input->GetTimeGeometry()->GetTimeBounds(t);
           filename << m_FileName.c_str() << "_S" << std::setprecision(0) << timebounds[0] << "_E"
                    << std::setprecision(0) << timebounds[1] << "_T" << t << GetDefaultExtension();
         }
         else
         {
           itkWarningMacro(<< "Error on write: TimeGeometry invalid of unstructured grid " << filename.str() << ".");
           filename << m_FileName.c_str() << "_T" << t << GetDefaultExtension();
         }
         transformPointSet->SetInputData(input->GetVtkUnstructuredGrid(t));
         transformPointSet->SetTransform(geometry->GetVtkTransform());
         transformPointSet->UpdateWholeExtent();
         unstructuredGrid = static_cast<vtkUnstructuredGrid *>(transformPointSet->GetOutput());
 
         unstructuredGridWriter->SetFileName(filename.str().c_str());
         unstructuredGridWriter->SetInputData(unstructuredGrid);
 
         ExecuteWrite(unstructuredGridWriter);
       }
     }
     else
     {
       geometry = input->GetGeometry();
       transformPointSet->SetInputData(input->GetVtkUnstructuredGrid());
       transformPointSet->SetTransform(geometry->GetVtkTransform());
       transformPointSet->UpdateWholeExtent();
       unstructuredGrid = static_cast<vtkUnstructuredGrid *>(transformPointSet->GetOutput());
 
       unstructuredGridWriter->SetFileName(m_FileName.c_str());
       unstructuredGridWriter->SetInputData(unstructuredGrid);
 
       ExecuteWrite(unstructuredGridWriter);
     }
     transformPointSet->Delete();
     unstructuredGridWriter->Delete();
 
     m_Success = true;
   }
 
   template <class VTKWRITER>
   void UnstructuredGridVtkWriter<VTKWRITER>::ExecuteWrite(VTKWRITER *vtkWriter)
   {
     struct stat fileStatus;
     time_t timeBefore = 0;
     if (!stat(vtkWriter->GetFileName(), &fileStatus))
     {
       timeBefore = fileStatus.st_mtime;
     }
     if (!vtkWriter->Write())
     {
       itkExceptionMacro(<< "Error during unstructured grid writing.");
     }
 
     // check if file can be written because vtkWriter doesn't check that
     if (stat(vtkWriter->GetFileName(), &fileStatus) || (timeBefore == fileStatus.st_mtime))
     {
       itkExceptionMacro(<< "Error during unstructured grid writing: file could not be written");
     }
   }
 
   template <class VTKWRITER>
   void UnstructuredGridVtkWriter<VTKWRITER>::SetInput(BaseData *input)
   {
     this->ProcessObject::SetNthInput(0, input);
   }
 
   template <class VTKWRITER>
   const UnstructuredGrid *UnstructuredGridVtkWriter<VTKWRITER>::GetInput()
   {
     if (this->GetNumberOfInputs() < 1)
     {
       return nullptr;
     }
     else
     {
       return dynamic_cast<UnstructuredGrid *>(this->ProcessObject::GetInput(0));
     }
   }
 
   template <class VTKWRITER>
   bool UnstructuredGridVtkWriter<VTKWRITER>::CanWriteBaseDataType(BaseData::Pointer data)
   {
     return (dynamic_cast<mitk::UnstructuredGrid *>(data.GetPointer()) != nullptr);
   }
 
   template <class VTKWRITER>
   void UnstructuredGridVtkWriter<VTKWRITER>::DoWrite(BaseData::Pointer data)
   {
     if (CanWriteBaseDataType(data))
     {
       this->SetInput(dynamic_cast<mitk::UnstructuredGrid *>(data.GetPointer()));
       this->Update();
     }
   }
 
   template <class VTKWRITER>
   std::vector<std::string> UnstructuredGridVtkWriter<VTKWRITER>::GetPossibleFileExtensions()
   {
     throw std::exception(); // no specialization available!
   }
 
   template <class VTKWRITER>
   const char *UnstructuredGridVtkWriter<VTKWRITER>::GetDefaultFilename()
   {
     throw std::exception(); // no specialization available!
   }
 
   template <class VTKWRITER>
   const char *UnstructuredGridVtkWriter<VTKWRITER>::GetFileDialogPattern()
   {
     throw std::exception(); // no specialization available!
   }
 
   template <class VTKWRITER>
   const char *UnstructuredGridVtkWriter<VTKWRITER>::GetDefaultExtension()
   {
     throw std::exception(); // no specialization available!
   }
 }
 
 #endif
diff --git a/Modules/LegacyIO/mitkImageWriter.cpp b/Modules/LegacyIO/mitkImageWriter.cpp
index 4cec0c6130..1b80e14b55 100644
--- a/Modules/LegacyIO/mitkImageWriter.cpp
+++ b/Modules/LegacyIO/mitkImageWriter.cpp
@@ -1,476 +1,476 @@
 /*============================================================================
 
 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 "mitkImageWriter.h"
 
 #include "mitkImage.h"
 #include "mitkImageAccessByItk.h"
 #include "mitkImageReadAccessor.h"
 #include "mitkImageTimeSelector.h"
 #include "mitkItkPictureWrite.h"
 #include <mitkLocaleSwitch.h>
 
 #include <itkImageIOBase.h>
 #include <itkImageIOFactory.h>
 
 mitk::ImageWriter::ImageWriter() : m_UseCompression(true)
 {
   this->SetNumberOfRequiredInputs(1);
   m_MimeType = "";
   SetDefaultExtension();
 }
 
 mitk::ImageWriter::~ImageWriter()
 {
 }
 
 void mitk::ImageWriter::SetFileName(const char *fileName)
 {
   if (fileName && (fileName == this->m_FileName))
   {
     return;
   }
   if (fileName)
   {
     this->m_FileName = fileName;
     this->m_FileNameWithoutExtension = this->m_FileName;
     this->m_Extension.clear();
     std::size_t pos = this->m_FileName.find_last_of("/\\");
     if (pos != std::string::npos)
     {
       std::size_t ppos = this->m_FileName.find_first_of('.', pos);
       if (ppos != std::string::npos)
       {
         this->m_FileNameWithoutExtension = this->m_FileName.substr(0, ppos);
         this->m_Extension = this->m_FileName.substr(ppos);
       }
     }
   }
   else
   {
     this->m_FileName.clear();
     this->m_FileNameWithoutExtension.clear();
     this->m_Extension.clear();
   }
   this->Modified();
 }
 
 void mitk::ImageWriter::SetFileName(const std::string &fileName)
 {
   this->SetFileName(fileName.c_str());
 }
 
 void mitk::ImageWriter::SetExtension(const char *extension)
 {
   if (extension && (extension == this->m_Extension))
   {
     return;
   }
   if (extension)
   {
     this->m_Extension = extension;
     this->m_FileName = this->m_FileNameWithoutExtension + this->m_Extension;
   }
   else
   {
     this->m_Extension.clear();
     this->m_FileName = this->m_FileNameWithoutExtension;
   }
   this->Modified();
 }
 
 void mitk::ImageWriter::SetExtension(const std::string &extension)
 {
   this->SetFileName(extension.c_str());
 }
 
 void mitk::ImageWriter::SetDefaultExtension()
 {
   this->m_Extension = ".mhd";
   this->m_FileName = this->m_FileNameWithoutExtension + this->m_Extension;
   this->Modified();
 }
 
 #include <vtkConfigure.h>
 #include <vtkImageData.h>
 #include <vtkXMLImageDataWriter.h>
 static void writeVti(const char *filename, mitk::Image *image, int t = 0)
 {
   vtkXMLImageDataWriter *vtkwriter = vtkXMLImageDataWriter::New();
   vtkwriter->SetFileName(filename);
   vtkwriter->SetInputData(image->GetVtkImageData(t));
   vtkwriter->Write();
   vtkwriter->Delete();
 }
 
 #include <itkRGBAPixel.h>
 
 void mitk::ImageWriter::WriteByITK(mitk::Image *image, const std::string &fileName)
 {
   MITK_INFO << "Writing image: " << fileName << std::endl;
   // Pictures and picture series like .png are written via a different mechanism then volume images.
   // So, they are still multiplexed and thus not support vector images.
   if (fileName.find(".png") != std::string::npos || fileName.find(".tif") != std::string::npos ||
       fileName.find(".jpg") != std::string::npos || fileName.find(".bmp") != std::string::npos)
   {
     try
     {
       // switch processing of single/multi-component images
       if (image->GetPixelType(0).GetNumberOfComponents() == 1)
       {
         AccessByItk_1(image, _mitkItkPictureWrite, fileName);
       }
       else
       {
         AccessFixedPixelTypeByItk_1(image,
                                     _mitkItkPictureWriteComposite,
                                     MITK_ACCESSBYITK_PIXEL_TYPES_SEQ MITK_ACCESSBYITK_COMPOSITE_PIXEL_TYPES_SEQ,
                                     fileName);
       }
     }
     catch (itk::ExceptionObject &e)
     {
       std::cerr << "Caught " << e.what() << std::endl;
     }
     catch (std::exception &e)
     {
       std::cerr << "Caught std::exception " << e.what() << std::endl;
     }
 
     return;
   }
 
   // Implementation of writer using itkImageIO directly. This skips the use
   // of templated itkImageFileWriter, which saves the multiplexing on MITK side.
 
   unsigned int dimension = image->GetDimension();
   unsigned int *dimensions = image->GetDimensions();
   mitk::PixelType pixelType = image->GetPixelType();
   mitk::Vector3D mitkSpacing = image->GetGeometry()->GetSpacing();
   mitk::Point3D mitkOrigin = image->GetGeometry()->GetOrigin();
 
   // Due to templating in itk, we are forced to save a 4D spacing and 4D Origin, though they are not supported in MITK
   itk::Vector<double, 4u> spacing4D;
   spacing4D[0] = mitkSpacing[0];
   spacing4D[1] = mitkSpacing[1];
   spacing4D[2] = mitkSpacing[2];
   spacing4D[3] = 1; // There is no support for a 4D spacing. However, we should have an valid value here
 
   itk::Vector<double, 4u> origin4D;
   origin4D[0] = mitkOrigin[0];
   origin4D[1] = mitkOrigin[1];
   origin4D[2] = mitkOrigin[2];
   origin4D[3] = 0; // There is no support for a 4D origin. However, we should have an valid value here
 
   itk::ImageIOBase::Pointer imageIO =
     itk::ImageIOFactory::CreateImageIO(fileName.c_str(), itk::ImageIOFactory::WriteMode);
 
   if (imageIO.IsNull())
   {
     itkExceptionMacro(<< "Error: Could not create itkImageIO via factory for file " << fileName);
   }
 
   // Set the necessary information for imageIO
   imageIO->SetNumberOfDimensions(dimension);
   imageIO->SetPixelType(pixelType.GetPixelType());
   imageIO->SetComponentType(pixelType.GetComponentType() < PixelComponentUserType ?
                               static_cast<itk::ImageIOBase::IOComponentType>(pixelType.GetComponentType()) :
                               itk::ImageIOBase::UNKNOWNCOMPONENTTYPE);
   imageIO->SetNumberOfComponents(pixelType.GetNumberOfComponents());
 
   itk::ImageIORegion ioRegion(dimension);
 
   for (unsigned int i = 0; i < dimension; i++)
   {
     imageIO->SetDimensions(i, dimensions[i]);
     imageIO->SetSpacing(i, spacing4D[i]);
     imageIO->SetOrigin(i, origin4D[i]);
 
     mitk::Vector3D mitkDirection;
     mitkDirection.SetVnlVector(
       image->GetGeometry()->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(i));
     itk::Vector<double, 4u> direction4D;
     direction4D[0] = mitkDirection[0];
     direction4D[1] = mitkDirection[1];
     direction4D[2] = mitkDirection[2];
 
     // MITK only supports a 3x3 direction matrix. Due to templating in itk, however, we must
     // save a 4x4 matrix for 4D images. in this case, add an homogneous component to the matrix.
     if (i == 3)
       direction4D[3] = 1; // homogenous component
     else
       direction4D[3] = 0;
 
     vnl_vector<double> axisDirection(dimension);
     for (unsigned int j = 0; j < dimension; j++)
     {
       axisDirection[j] = direction4D[j] / spacing4D[i];
     }
     imageIO->SetDirection(i, axisDirection);
 
     ioRegion.SetSize(i, image->GetLargestPossibleRegion().GetSize(i));
     ioRegion.SetIndex(i, image->GetLargestPossibleRegion().GetIndex(i));
   }
 
   // use compression if available
   imageIO->SetUseCompression(m_UseCompression);
 
   imageIO->SetIORegion(ioRegion);
   imageIO->SetFileName(fileName);
 
   ImageReadAccessor imageAccess(image);
   imageIO->Write(imageAccess.GetData());
 }
 
 void mitk::ImageWriter::GenerateData()
 {
   mitk::LocaleSwitch localeSwitch("C");
 
   if (m_FileName == "")
   {
     itkWarningMacro(<< "Sorry, filename has not been set!");
     return;
   }
 
   FILE *tempFile = fopen(m_FileName.c_str(), "w");
   if (tempFile == nullptr)
   {
     itkExceptionMacro(<< "File location not writeable");
     return;
   }
   fclose(tempFile);
   remove(m_FileName.c_str());
 
   // Creating clone of input image, since i might change the geometry
   mitk::Image::Pointer input = this->GetInput()->Clone();
 
   // Check if geometry information will be lost
   if (input->GetDimension() == 2)
   {
     if (!input->GetGeometry()->Is2DConvertable())
     {
       MITK_WARN << "Saving a 2D image with 3D geometry information. Geometry information will be lost! You might "
                    "consider using Convert2Dto3DImageFilter before saving.";
 
       // set matrix to identity
       mitk::AffineTransform3D::Pointer affTrans = mitk::AffineTransform3D::New();
       affTrans->SetIdentity();
       mitk::Vector3D spacing = input->GetGeometry()->GetSpacing();
       mitk::Point3D origin = input->GetGeometry()->GetOrigin();
       input->GetGeometry()->SetIndexToWorldTransform(affTrans);
       input->GetGeometry()->SetSpacing(spacing);
       input->GetGeometry()->SetOrigin(origin);
     }
   }
 
   bool vti = (m_Extension.find(".vti") != std::string::npos);
 
   // If the extension is NOT .pic and NOT .nrrd and NOT .nii and NOT .nii.gz the following block is entered
   if (m_Extension.find(".pic") == std::string::npos && m_Extension.find(".nrrd") == std::string::npos &&
       m_Extension.find(".nii") == std::string::npos && m_Extension.find(".nii.gz") == std::string::npos)
   {
     if (input->GetDimension() > 3)
     {
       int t, timesteps;
 
       timesteps = input->GetDimension(3);
       ImageTimeSelector::Pointer timeSelector = ImageTimeSelector::New();
       timeSelector->SetInput(input);
       mitk::Image::Pointer image = timeSelector->GetOutput();
       for (t = 0; t < timesteps; ++t)
       {
         std::ostringstream filename;
         timeSelector->SetTimeNr(t);
         timeSelector->Update();
         if (input->GetTimeGeometry()->IsValidTimeStep(t))
         {
-          const mitk::TimeBounds &timebounds = input->GetTimeGeometry()->GetTimeBounds(t);
+          const mitk::TimeBounds timebounds = input->GetTimeGeometry()->GetTimeBounds(t);
           filename << m_FileNameWithoutExtension << "_S" << std::setprecision(0) << timebounds[0] << "_E"
                    << std::setprecision(0) << timebounds[1] << "_T" << t << m_Extension;
         }
         else
         {
           itkWarningMacro(<< "Error on write: TimeGeometry invalid of image " << filename.str() << ".");
           filename << m_FileNameWithoutExtension << "_T" << t << m_Extension;
         }
         if (vti)
         {
           writeVti(filename.str().c_str(), input, t);
         }
         else
         {
           WriteByITK(image, filename.str());
         }
       }
     }
     else if (vti)
     {
       writeVti(m_FileName.c_str(), input);
     }
     else
     {
       WriteByITK(input, m_FileName);
     }
   }
   else
   {
     // use the PicFileWriter for the .pic data type
     if (m_Extension.find(".pic") != std::string::npos)
     {
          /*    PicFileWriter::Pointer picWriter = PicFileWriter::New();
          size_t found;
          found = m_FileName.find( m_Extension ); // !!! HAS to be at the very end of the filename (not somewhere in the middle)
          if( m_FileName.length() > 3 && found != m_FileName.length() - 4 )
          {
          //if Extension not in Filename
          std::ostringstream filename;
          filename <<  m_FileName.c_str() << m_Extension;
          picWriter->SetFileName( filename.str().c_str() );
          }
          else
          {
          picWriter->SetFileName( m_FileName.c_str() );
          }
          picWriter->SetInputImage( input );
          picWriter->Write();
          */    }
 
          // use the ITK .nrrd Image writer
          if (m_Extension.find(".nrrd") != std::string::npos || m_Extension.find(".nii") != std::string::npos ||
              m_Extension.find(".nii.gz") != std::string::npos)
          {
            WriteByITK(input, this->m_FileName);
          }
   }
   m_MimeType = "application/MITK.Pic";
 }
 
 bool mitk::ImageWriter::CanWriteDataType(DataNode *input)
 {
   if (input)
   {
     return this->CanWriteBaseDataType(input->GetData());
   }
   return false;
 }
 
 void mitk::ImageWriter::SetInput(DataNode *input)
 {
   if (input && CanWriteDataType(input))
     this->ProcessObject::SetNthInput(0, dynamic_cast<mitk::Image *>(input->GetData()));
 }
 
 std::string mitk::ImageWriter::GetWritenMIMEType()
 {
   return m_MimeType;
 }
 
 std::vector<std::string> mitk::ImageWriter::GetPossibleFileExtensions()
 {
   std::vector<std::string> possibleFileExtensions;
   possibleFileExtensions.push_back(".pic");
   possibleFileExtensions.push_back(".pic.gz");
   possibleFileExtensions.push_back(".bmp");
   possibleFileExtensions.push_back(".dcm");
   possibleFileExtensions.push_back(".DCM");
   possibleFileExtensions.push_back(".dicom");
   possibleFileExtensions.push_back(".DICOM");
   possibleFileExtensions.push_back(".gipl");
   possibleFileExtensions.push_back(".gipl.gz");
   possibleFileExtensions.push_back(".mha");
   possibleFileExtensions.push_back(".nii");
   possibleFileExtensions.push_back(".nii.gz");
   possibleFileExtensions.push_back(".nrrd");
   possibleFileExtensions.push_back(".nhdr");
   possibleFileExtensions.push_back(".png");
   possibleFileExtensions.push_back(".PNG");
   possibleFileExtensions.push_back(".spr");
   possibleFileExtensions.push_back(".mhd");
   possibleFileExtensions.push_back(".vtk");
   possibleFileExtensions.push_back(".vti");
   possibleFileExtensions.push_back(".hdr");
   possibleFileExtensions.push_back(".img");
   possibleFileExtensions.push_back(".img.gz");
   possibleFileExtensions.push_back(".png");
   possibleFileExtensions.push_back(".tif");
   possibleFileExtensions.push_back(".jpg");
   return possibleFileExtensions;
 }
 
 std::string mitk::ImageWriter::GetSupportedBaseData() const
 {
   return Image::GetStaticNameOfClass();
 }
 
 std::string mitk::ImageWriter::GetFileExtension()
 {
   return m_Extension;
 }
 
 void mitk::ImageWriter::SetInput(mitk::Image *image)
 {
   this->ProcessObject::SetNthInput(0, image);
 }
 
 const mitk::Image *mitk::ImageWriter::GetInput()
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return nullptr;
   }
   else
   {
     return static_cast<const mitk::Image *>(this->ProcessObject::GetInput(0));
   }
 }
 
 const char *mitk::ImageWriter::GetDefaultFilename()
 {
   return "Image.nrrd";
 }
 
 const char *mitk::ImageWriter::GetFileDialogPattern()
 {
   return "Nearly Raw Raster Data (*.nrrd);;"
          "NIfTI format (*.nii *.nii.gz);;"
          "VTK Image Data Files (*.vti);;"
          "NRRD with detached header (*.nhdr);;"
          "Analyze Format (*.hdr);;"
          "MetaImage (*.mhd);;"
          "Sets of 2D slices (*.png *.tiff *.jpg *.jpeg *.bmp);;"
          "DICOM (*.dcm *.DCM *.dicom *.DICOM);;"
          "UMDS GIPL Format Files (*.gipl *.gipl.gz)";
 }
 
 const char *mitk::ImageWriter::GetDefaultExtension()
 {
   return ".nrrd";
 }
 
 bool mitk::ImageWriter::CanWriteBaseDataType(BaseData::Pointer data)
 {
   return dynamic_cast<mitk::Image *>(data.GetPointer());
 }
 
 void mitk::ImageWriter::DoWrite(BaseData::Pointer data)
 {
   if (this->CanWriteBaseDataType(data))
   {
     this->SetInput(dynamic_cast<mitk::Image *>(data.GetPointer()));
     this->Update();
   }
 }
 
 void mitk::ImageWriter::SetUseCompression(bool useCompression)
 {
   m_UseCompression = useCompression;
 }
diff --git a/Modules/LegacyIO/mitkSurfaceVtkWriter.txx b/Modules/LegacyIO/mitkSurfaceVtkWriter.txx
index 82b0c18fab..3072e4634c 100644
--- a/Modules/LegacyIO/mitkSurfaceVtkWriter.txx
+++ b/Modules/LegacyIO/mitkSurfaceVtkWriter.txx
@@ -1,171 +1,171 @@
 /*============================================================================
 
 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 "mitkSurfaceVtkWriter.h"
 #include <vtkConfigure.h>
 #include <vtkErrorCode.h>
 #include <vtkLinearTransform.h>
 #include <vtkPolyData.h>
 #include <vtkTransformPolyDataFilter.h>
 
 #include <sstream>
 #include <cstdio>
 #include <sys/stat.h>
 #include <sys/types.h>
 
 template <class VTKWRITER>
 mitk::SurfaceVtkWriter<VTKWRITER>::SurfaceVtkWriter() : m_WriterWriteHasReturnValue(false)
 {
   this->SetNumberOfRequiredInputs(1);
 
   m_VtkWriter = vtkSmartPointer<VtkWriterType>::New();
 
   // enable to write ascii-formatted-file
   // m_VtkWriter->SetFileTypeToASCII();
 
   SetDefaultExtension(); // and information about the Writer's Write() method
 }
 
 template <class VTKWRITER>
 mitk::SurfaceVtkWriter<VTKWRITER>::~SurfaceVtkWriter()
 {
 }
 
 template <class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::SetDefaultExtension()
 {
   m_Extension = ".vtk";
 }
 
 template <class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::ExecuteWrite(VtkWriterType *vtkWriter)
 {
   if (vtkWriter->Write() == 0 || vtkWriter->GetErrorCode() != 0)
   {
     itkExceptionMacro(<< "Error during surface writing: "
                       << vtkErrorCode::GetStringFromErrorCode(vtkWriter->GetErrorCode()));
   }
 }
 
 template <class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::GenerateData()
 {
   if (m_FileName == "")
   {
     itkWarningMacro(<< "Sorry, filename has not been set!");
     return;
   }
 
   mitk::Surface::Pointer input = const_cast<mitk::Surface *>(this->GetInput());
 
   vtkSmartPointer<vtkTransformPolyDataFilter> transformPolyData = vtkSmartPointer<vtkTransformPolyDataFilter>::New();
   vtkPolyData *polyData;
   BaseGeometry *geometry;
 
   unsigned int t, timesteps = input->GetTimeGeometry()->CountTimeSteps();
 
   for (t = 0; t < timesteps; ++t)
   {
     // surfaces do not have to exist in all timeteps; therefor, only write valid surfaces
     if (input->GetVtkPolyData(t) == nullptr)
       continue;
 
     std::ostringstream filename;
     filename.imbue(::std::locale::classic());
     geometry = input->GetGeometry(t);
     if (timesteps > 1)
     {
       if (input->GetTimeGeometry()->IsValidTimeStep(t))
       {
-        const TimeBounds &timebounds = input->GetTimeGeometry()->GetTimeBounds(t);
+        const TimeBounds timebounds = input->GetTimeGeometry()->GetTimeBounds(t);
         filename << m_FileName.c_str() << "_S" << std::setprecision(0) << timebounds[0] << "_E" << std::setprecision(0)
                  << timebounds[1] << "_T" << t << m_Extension;
       }
       else
       {
         itkWarningMacro(<< "Error on write: TimeGeometry invalid of surface " << filename.str() << ".");
         filename << m_FileName.c_str() << "_T" << t << m_Extension;
       }
       m_VtkWriter->SetFileName(filename.str().c_str());
     }
     else
       m_VtkWriter->SetFileName(m_FileName.c_str());
 
     transformPolyData->SetInputData(input->GetVtkPolyData(t));
     transformPolyData->SetTransform(geometry->GetVtkTransform());
     transformPolyData->UpdateWholeExtent();
     polyData = transformPolyData->GetOutput();
 
     m_VtkWriter->SetInputData(polyData);
 
     ExecuteWrite(m_VtkWriter);
   }
 
   m_MimeType = "application/MITK.Surface";
 }
 
 template <class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::SetInput(mitk::Surface *surface)
 {
   this->ProcessObject::SetNthInput(0, surface);
 }
 
 template <class VTKWRITER>
 const mitk::Surface *mitk::SurfaceVtkWriter<VTKWRITER>::GetInput()
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return nullptr;
   }
   else
   {
     return static_cast<const Surface *>(this->ProcessObject::GetInput(0));
   }
 }
 
 template <class VTKWRITER>
 bool mitk::SurfaceVtkWriter<VTKWRITER>::CanWriteDataType(DataNode *input)
 {
   if (input)
   {
     BaseData *data = input->GetData();
     if (data)
     {
       Surface::Pointer surface = dynamic_cast<Surface *>(data);
       if (surface.IsNotNull())
       {
         SetDefaultExtension();
         return true;
       }
     }
   }
   return false;
 }
 
 template <class VTKWRITER>
 void mitk::SurfaceVtkWriter<VTKWRITER>::SetInput(DataNode *input)
 {
   if (input && CanWriteDataType(input))
     SetInput(dynamic_cast<Surface *>(input->GetData()));
 }
 
 template <class VTKWRITER>
 std::string mitk::SurfaceVtkWriter<VTKWRITER>::GetWritenMIMEType()
 {
   return m_MimeType;
 }
 
 template <class VTKWRITER>
 std::string mitk::SurfaceVtkWriter<VTKWRITER>::GetFileExtension()
 {
   return m_Extension;
 }
diff --git a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
index faa81aca74..5870887320 100644
--- a/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
+++ b/Modules/Segmentation/Interactions/mitkLiveWireTool2D.cpp
@@ -1,628 +1,620 @@
 /*============================================================================
 
 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 <mitkContourModelUtils.h>
 #include <mitkLiveWireTool2D.h>
 #include <mitkLiveWireTool2D.xpm>
 #include <mitkToolManager.h>
 
 #include <usGetModuleContext.h>
 #include <usModuleResource.h>
 
 #include <type_traits>
 
 namespace mitk
 {
   MITK_TOOL_MACRO(MITKSEGMENTATION_EXPORT, LiveWireTool2D, "LiveWire tool");
 }
 
 mitk::LiveWireTool2D::LiveWireTool2D()
   : SegTool2D("LiveWireTool"), m_CreateAndUseDynamicCosts(false)
 {
 }
 
 mitk::LiveWireTool2D::~LiveWireTool2D()
 {
   this->ClearSegmentation();
 }
 
 void mitk::LiveWireTool2D::RemoveHelperObjects()
 {
   auto dataStorage = m_ToolManager->GetDataStorage();
 
   if (nullptr == dataStorage)
     return;
 
   for (const auto &editingContour : m_EditingContours)
     dataStorage->Remove(editingContour.first);
 
   for (const auto &workingContour : m_WorkingContours)
     dataStorage->Remove(workingContour.first);
 
   if (m_EditingContourNode.IsNotNull())
     dataStorage->Remove(m_EditingContourNode);
 
   if (m_LiveWireContourNode.IsNotNull())
     dataStorage->Remove(m_LiveWireContourNode);
 
   if (m_ContourNode.IsNotNull())
     dataStorage->Remove(m_ContourNode);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void mitk::LiveWireTool2D::ReleaseHelperObjects()
 {
   this->RemoveHelperObjects();
 
   m_EditingContours.clear();
   m_WorkingContours.clear();
 
   m_EditingContourNode = nullptr;
   m_EditingContour = nullptr;
 
   m_LiveWireContourNode = nullptr;
   m_LiveWireContour = nullptr;
 
   m_ContourNode = nullptr;
   m_Contour = nullptr;
 }
 
 void mitk::LiveWireTool2D::ReleaseInteractors()
 {
   this->EnableContourLiveWireInteraction(false);
   m_LiveWireInteractors.clear();
 }
 
 void mitk::LiveWireTool2D::ConnectActionsAndFunctions()
 {
   CONNECT_CONDITION("CheckContourClosed", OnCheckPoint);
 
   CONNECT_FUNCTION("InitObject", OnInitLiveWire);
   CONNECT_FUNCTION("AddPoint", OnAddPoint);
   CONNECT_FUNCTION("CtrlAddPoint", OnAddPoint);
   CONNECT_FUNCTION("MovePoint", OnMouseMoveNoDynamicCosts);
   CONNECT_FUNCTION("FinishContour", OnFinish);
   CONNECT_FUNCTION("DeletePoint", OnLastSegmentDelete);
   CONNECT_FUNCTION("CtrlMovePoint", OnMouseMoved);
 }
 
 const char **mitk::LiveWireTool2D::GetXPM() const
 {
   return mitkLiveWireTool2D_xpm;
 }
 
 us::ModuleResource mitk::LiveWireTool2D::GetIconResource() const
 {
   return us::GetModuleContext()->GetModule()->GetResource("LiveWire_48x48.png");
 }
 
 us::ModuleResource mitk::LiveWireTool2D::GetCursorIconResource() const
 {
   return us::GetModuleContext()->GetModule()->GetResource("LiveWire_Cursor_32x32.png");
 }
 
 const char *mitk::LiveWireTool2D::GetName() const
 {
   return "Live Wire";
 }
 
 void mitk::LiveWireTool2D::Activated()
 {
   Superclass::Activated();
   this->ResetToStartState();
   this->EnableContourLiveWireInteraction(true);
 }
 
 void mitk::LiveWireTool2D::Deactivated()
 {
   this->ConfirmSegmentation();
   Superclass::Deactivated();
 }
 
 void mitk::LiveWireTool2D::UpdateLiveWireContour()
 {
   if (m_Contour.IsNotNull())
   {
     auto timeGeometry = m_Contour->GetTimeGeometry()->Clone();
     m_LiveWireContour = this->m_LiveWireFilter->GetOutput();
     m_LiveWireContour->SetTimeGeometry(timeGeometry); //needed because the results of the filter are always from 0 ms to 1 ms and the filter also resets its outputs.
     m_LiveWireContourNode->SetData(this->m_LiveWireContour);
   }
 }
 
 void mitk::LiveWireTool2D::OnTimePointChanged()
 {
   auto reference = this->GetReferenceData();
   if (nullptr == reference || m_PlaneGeometry.IsNull() || m_LiveWireFilter.IsNull() || m_LiveWireContourNode.IsNull())
     return;
 
   auto timeStep = reference->GetTimeGeometry()->TimePointToTimeStep(this->GetLastTimePointTriggered());
 
   m_ReferenceDataSlice = GetAffectedImageSliceAs2DImageByTimePoint(m_PlaneGeometry, reference, timeStep);
   m_LiveWireFilter->SetInput(m_ReferenceDataSlice);
 
   m_LiveWireFilter->Update();
 
   this->UpdateLiveWireContour();
 
   RenderingManager::GetInstance()->RequestUpdateAll();
 };
 
 
 void mitk::LiveWireTool2D::EnableContourLiveWireInteraction(bool on)
 {
   for (const auto &interactor : m_LiveWireInteractors)
     interactor->EnableInteraction(on);
 }
 
 void mitk::LiveWireTool2D::ConfirmSegmentation()
 {
   auto referenceImage = this->GetReferenceData();
   auto workingImage = this->GetWorkingData();
 
   if (nullptr != referenceImage && nullptr != workingImage)
   {
     std::vector<SliceInformation> sliceInfos;
     sliceInfos.reserve(m_WorkingContours.size());
 
     const auto currentTimePoint = mitk::RenderingManager::GetInstance()->GetTimeNavigationController()->GetSelectedTimePoint();
     TimeStepType workingImageTimeStep = workingImage->GetTimeGeometry()->TimePointToTimeStep(currentTimePoint);
 
     for (const auto &workingContour : m_WorkingContours)
     {
       auto contour = dynamic_cast<ContourModel *>(workingContour.first->GetData());
 
       if (nullptr == contour || contour->IsEmpty())
         continue;
 
       auto sameSlicePredicate = [&workingContour, workingImageTimeStep](const SliceInformation& si) { return workingContour.second->IsOnPlane(si.plane) && workingImageTimeStep == si.timestep; };
 
       auto finding = std::find_if(sliceInfos.begin(), sliceInfos.end(), sameSlicePredicate);
       if (finding == sliceInfos.end())
       {
         auto workingSlice = this->GetAffectedImageSliceAs2DImage(workingContour.second, workingImage, workingImageTimeStep)->Clone();
         sliceInfos.emplace_back(workingSlice, workingContour.second, workingImageTimeStep);
         finding = std::prev(sliceInfos.end());
       }
 
       //cast const away is OK in this case, because these are all slices created and manipulated
       //localy in this function call. And we want to keep the high constness of SliceInformation for
       //public interfaces.
       auto workingSlice = const_cast<Image*>(finding->slice.GetPointer());
 
       auto projectedContour = ContourModelUtils::ProjectContourTo2DSlice(workingSlice, contour, true, false);
       int activePixelValue = ContourModelUtils::GetActivePixelValue(workingImage);
 
       ContourModelUtils::FillContourInSlice(
         projectedContour, workingSlice, workingImage, activePixelValue);
     }
 
     this->WriteBackSegmentationResults(sliceInfos);
   }
 
   this->ClearSegmentation();
 }
 
 void mitk::LiveWireTool2D::ClearSegmentation()
 {
   this->ReleaseHelperObjects();
   this->ReleaseInteractors();
   this->ResetToStartState();
 }
 
 bool mitk::LiveWireTool2D::IsPositionEventInsideImageRegion(mitk::InteractionPositionEvent *positionEvent,
                                                             mitk::BaseData *data)
 {
   bool isPositionEventInsideImageRegion = nullptr != data && data->GetGeometry()->IsInside(positionEvent->GetPositionInWorld());
 
   if (!isPositionEventInsideImageRegion)
     MITK_WARN("LiveWireTool2D") << "PositionEvent is outside ImageRegion!";
 
   return isPositionEventInsideImageRegion;
 }
 
 mitk::ContourModel::Pointer mitk::LiveWireTool2D::CreateNewContour() const
 {
   auto workingData = this->GetWorkingData();
   if (nullptr == workingData)
   {
     this->InteractiveSegmentationBugMessage("Cannot create new contour. No valid working data is set. Application is in invalid state.");
     mitkThrow() << "Cannot create new contour. No valid working data is set. Application is in invalid state.";
   }
 
-  const auto minTime = workingData->GetTimeGeometry()->GetMinimumTimePoint();
-  auto duration = workingData->GetTimeGeometry()->GetMaximumTimePoint() - minTime;
-
-  if (duration <= 0)
-  {
-    duration = 1.;
-  };
-
   auto contour = ContourModel::New();
 
   //generate a time geometry that is always visible as the working contour should always be.
   auto contourTimeGeometry = ProportionalTimeGeometry::New();
   contourTimeGeometry->SetStepDuration(std::numeric_limits<TimePointType>::max());
   contourTimeGeometry->SetTimeStepGeometry(contour->GetTimeGeometry()->GetGeometryForTimeStep(0)->Clone(), 0);
   contour->SetTimeGeometry(contourTimeGeometry);
 
   return contour;
 }
 
 void mitk::LiveWireTool2D::OnInitLiveWire(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
 
   if (nullptr == positionEvent)
     return;
 
   auto workingDataNode = this->GetWorkingDataNode();
 
   if (!IsPositionEventInsideImageRegion(positionEvent, workingDataNode->GetData()))
   {
     this->ResetToStartState();
     return;
   }
 
   m_LastEventSender = positionEvent->GetSender();
   m_LastEventSlice = m_LastEventSender->GetSlice();
 
   m_Contour = this->CreateNewContour();
   m_ContourNode = mitk::DataNode::New();
   m_ContourNode->SetData(m_Contour);
   m_ContourNode->SetName("working contour node");
   m_ContourNode->SetProperty("layer", IntProperty::New(100));
   m_ContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
   m_ContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_ContourNode->AddProperty("contour.color", ColorProperty::New(1.0f, 1.0f, 0.0f), nullptr, true);
   m_ContourNode->AddProperty("contour.points.color", ColorProperty::New(1.0f, 0.0f, 0.1f), nullptr, true);
   m_ContourNode->AddProperty("contour.controlpoints.show", BoolProperty::New(true), nullptr, true);
 
   m_LiveWireContour = this->CreateNewContour();
   m_LiveWireContourNode = mitk::DataNode::New();
   m_LiveWireContourNode->SetData(m_LiveWireContour);
   m_LiveWireContourNode->SetName("active livewire node");
   m_LiveWireContourNode->SetProperty("layer", IntProperty::New(101));
   m_LiveWireContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
   m_LiveWireContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_LiveWireContourNode->AddProperty("contour.color", ColorProperty::New(0.1f, 1.0f, 0.1f), nullptr, true);
   m_LiveWireContourNode->AddProperty("contour.width", mitk::FloatProperty::New(4.0f), nullptr, true);
 
   m_EditingContour = this->CreateNewContour();
   m_EditingContourNode = mitk::DataNode::New();
   m_EditingContourNode->SetData(m_EditingContour);
   m_EditingContourNode->SetName("editing node");
   m_EditingContourNode->SetProperty("layer", IntProperty::New(102));
   m_EditingContourNode->AddProperty("fixedLayer", BoolProperty::New(true));
   m_EditingContourNode->SetProperty("helper object", mitk::BoolProperty::New(true));
   m_EditingContourNode->AddProperty("contour.color", ColorProperty::New(0.1f, 1.0f, 0.1f), nullptr, true);
   m_EditingContourNode->AddProperty("contour.points.color", ColorProperty::New(0.0f, 0.0f, 1.0f), nullptr, true);
   m_EditingContourNode->AddProperty("contour.width", mitk::FloatProperty::New(4.0f), nullptr, true);
 
   auto dataStorage = m_ToolManager->GetDataStorage();
   dataStorage->Add(m_ContourNode, workingDataNode);
   dataStorage->Add(m_LiveWireContourNode, workingDataNode);
   dataStorage->Add(m_EditingContourNode, workingDataNode);
 
   // Set current slice as input for ImageToLiveWireContourFilter
   m_ReferenceDataSlice = this->GetAffectedReferenceSlice(positionEvent);
 
   auto origin = m_ReferenceDataSlice->GetSlicedGeometry()->GetOrigin();
   m_ReferenceDataSlice->GetSlicedGeometry()->WorldToIndex(origin, origin);
   m_ReferenceDataSlice->GetSlicedGeometry()->IndexToWorld(origin, origin);
   m_ReferenceDataSlice->GetSlicedGeometry()->SetOrigin(origin);
 
   m_LiveWireFilter = ImageLiveWireContourModelFilter::New();
   m_LiveWireFilter->SetInput(m_ReferenceDataSlice);
 
   // Map click to pixel coordinates
   auto click = positionEvent->GetPositionInWorld();
   itk::Index<3> idx;
   m_ReferenceDataSlice->GetGeometry()->WorldToIndex(click, idx);
 
   // Get the pixel with the highest gradient in a 7x7 region
   itk::Index<3> indexWithHighestGradient;
   AccessFixedDimensionByItk_2(m_ReferenceDataSlice, FindHighestGradientMagnitudeByITK, 2, idx, indexWithHighestGradient);
 
   click[0] = indexWithHighestGradient[0];
   click[1] = indexWithHighestGradient[1];
   click[2] = indexWithHighestGradient[2];
   m_ReferenceDataSlice->GetGeometry()->IndexToWorld(click, click);
 
   // Set initial start point
   m_Contour->AddVertex(click, true);
   m_LiveWireFilter->SetStartPoint(click);
 
   // Remember PlaneGeometry to determine if events were triggered in the same plane
   m_PlaneGeometry = interactionEvent->GetSender()->GetCurrentWorldPlaneGeometry();
 
   m_CreateAndUseDynamicCosts = true;
 
   mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 }
 
 void mitk::LiveWireTool2D::OnAddPoint(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   // Complete LiveWire interaction for the last segment. Add current LiveWire contour to
   // the finished contour and reset to start a new segment and computation.
 
   auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
 
   if (nullptr == positionEvent)
     return;
 
   if (m_PlaneGeometry.IsNotNull())
   {
     // Check if the point is in the correct slice
     if (m_PlaneGeometry->DistanceFromPlane(positionEvent->GetPositionInWorld()) > mitk::sqrteps)
       return;
   }
 
   // Add repulsive points to avoid getting the same path again
   std::for_each(m_LiveWireContour->IteratorBegin(), m_LiveWireContour->IteratorEnd(), [this](ContourElement::VertexType *vertex) {
     ImageLiveWireContourModelFilter::InternalImageType::IndexType idx;
     this->m_ReferenceDataSlice->GetGeometry()->WorldToIndex(vertex->Coordinates, idx);
     this->m_LiveWireFilter->AddRepulsivePoint(idx);
   });
 
   // Remove duplicate first vertex, it's already contained in m_Contour
   m_LiveWireContour->RemoveVertexAt(0);
 
   // Set last point as control point
   m_LiveWireContour->SetControlVertexAt(m_LiveWireContour->GetNumberOfVertices() - 1);
 
   // Merge contours
   m_Contour->Concatenate(m_LiveWireContour);
 
   // Clear the LiveWire contour and reset the corresponding DataNode
   m_LiveWireContour->Clear();
 
   // Set new start point
   m_LiveWireFilter->SetStartPoint(positionEvent->GetPositionInWorld());
 
   if (m_CreateAndUseDynamicCosts)
   {
     // Use dynamic cost map for next update
     m_LiveWireFilter->CreateDynamicCostMap(m_Contour);
     m_LiveWireFilter->SetUseDynamicCostMap(true);
   }
 
   mitk::RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 }
 
 void mitk::LiveWireTool2D::OnMouseMoved(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   // Compute LiveWire segment from last control point to current mouse position
 
   auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
 
   if (nullptr == positionEvent)
     return;
 
   m_LiveWireFilter->SetEndPoint(positionEvent->GetPositionInWorld());
   m_LiveWireFilter->Update();
 
   this->UpdateLiveWireContour();
 
   RenderingManager::GetInstance()->RequestUpdate(positionEvent->GetSender()->GetRenderWindow());
 }
 
 void mitk::LiveWireTool2D::OnMouseMoveNoDynamicCosts(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   m_LiveWireFilter->SetUseDynamicCostMap(false);
   this->OnMouseMoved(nullptr, interactionEvent);
   m_LiveWireFilter->SetUseDynamicCostMap(true);
 }
 
 bool mitk::LiveWireTool2D::OnCheckPoint(const InteractionEvent *interactionEvent)
 {
   // Check double click on first control point to finish the LiveWire tool
 
   auto positionEvent = dynamic_cast<const mitk::InteractionPositionEvent *>(interactionEvent);
 
   if (nullptr == positionEvent)
     return false;
 
   mitk::Point3D click = positionEvent->GetPositionInWorld();
   mitk::Point3D first = this->m_Contour->GetVertexAt(0)->Coordinates;
 
   return first.EuclideanDistanceTo(click) < 4.5;
 }
 
 void mitk::LiveWireTool2D::OnFinish(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   // Finish LiveWire tool interaction
 
   auto positionEvent = dynamic_cast<mitk::InteractionPositionEvent *>(interactionEvent);
 
   if (nullptr == positionEvent)
     return;
 
   // Remove last control point added by double click
   m_Contour->RemoveVertexAt(m_Contour->GetNumberOfVertices() - 1);
 
   // Save contour and corresponding plane geometry to list
   this->m_WorkingContours.emplace_back(std::make_pair(m_ContourNode, positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()->Clone()));
   this->m_EditingContours.emplace_back(std::make_pair(m_EditingContourNode, positionEvent->GetSender()->GetCurrentWorldPlaneGeometry()->Clone()));
 
   m_LiveWireFilter->SetUseDynamicCostMap(false);
 
   this->FinishTool();
 }
 
 void mitk::LiveWireTool2D::FinishTool()
 {
   auto numberOfTimesteps = static_cast<int>(m_Contour->GetTimeSteps());
 
   for (int i = 0; i <= numberOfTimesteps; ++i)
     m_Contour->Close(i);
 
   m_ToolManager->GetDataStorage()->Remove(m_LiveWireContourNode);
 
   m_LiveWireContourNode = nullptr;
   m_LiveWireContour = nullptr;
 
   m_ContourInteractor = mitk::ContourModelLiveWireInteractor::New();
   m_ContourInteractor->SetDataNode(m_ContourNode);
   m_ContourInteractor->LoadStateMachine("ContourModelModificationInteractor.xml", us::GetModuleContext()->GetModule());
   m_ContourInteractor->SetEventConfig("ContourModelModificationConfig.xml", us::GetModuleContext()->GetModule());
   m_ContourInteractor->SetWorkingImage(this->m_ReferenceDataSlice);
   m_ContourInteractor->SetEditingContourModelNode(this->m_EditingContourNode);
 
   m_ContourNode->SetDataInteractor(m_ContourInteractor.GetPointer());
 
   this->m_LiveWireInteractors.push_back(m_ContourInteractor);
 }
 
 void mitk::LiveWireTool2D::OnLastSegmentDelete(StateMachineAction *, InteractionEvent *interactionEvent)
 {
   // If last point of current contour will be removed go to start state and remove nodes
   if (m_Contour->GetNumberOfVertices() <= 1)
   {
     auto dataStorage = m_ToolManager->GetDataStorage();
 
     dataStorage->Remove(m_LiveWireContourNode);
     dataStorage->Remove(m_ContourNode);
     dataStorage->Remove(m_EditingContourNode);
 
     m_LiveWireContour = this->CreateNewContour();
     m_LiveWireContourNode->SetData(m_LiveWireContour);
 
     m_Contour = this->CreateNewContour();
     m_ContourNode->SetData(m_Contour);
 
     this->ResetToStartState();
   }
   else // Remove last segment from contour and reset LiveWire contour
   {
     m_LiveWireContour = this->CreateNewContour();
     m_LiveWireContourNode->SetData(m_LiveWireContour);
 
     auto newContour = this->CreateNewContour();
 
     auto begin = m_Contour->IteratorBegin();
 
     // Iterate from last point to next active point
     auto 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);
 
     auto it = m_Contour->IteratorBegin();
 
     // Fll new Contour
     while (it <= newLast)
     {
       newContour->AddVertex((*it)->Coordinates, (*it)->IsControlPoint);
       ++it;
     }
 
     newContour->SetClosed(m_Contour->IsClosed());
 
     m_ContourNode->SetData(newContour);
     m_Contour = newContour;
 
     mitk::RenderingManager::GetInstance()->RequestUpdate(interactionEvent->GetSender()->GetRenderWindow());
   }
 }
 
 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;
 
   const auto MAX_X = inputImage->GetLargestPossibleRegion().GetSize()[0];
   const auto MAX_Y = 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 (MAX_X - index[0] < 7)
     startRegion[0] = MAX_X - 7;
   if (MAX_Y - index[1] < 7)
     startRegion[1] = MAX_Y - 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 gradientMagnitudeImage;
   gradientMagnitudeImage = 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 = gradientMagnitudeImage->GetPixel(currentIndex);
 
       // Check for new max
       if (maxGradientMagnitude < gradientMagnitude)
       {
         maxGradientMagnitude = gradientMagnitude;
         returnIndex[0] = currentIndex[0];
         returnIndex[1] = currentIndex[1];
         returnIndex[2] = 0.0;
       }
     }
 
     currentIndex[1] = index[1];
   }
 }