diff --git a/Modules/Segmentation/Algorithms/mitkContourModelSetToImageFilter.cpp b/Modules/Segmentation/Algorithms/mitkContourModelSetToImageFilter.cpp
index 7c6a44a554..65cae86e50 100644
--- a/Modules/Segmentation/Algorithms/mitkContourModelSetToImageFilter.cpp
+++ b/Modules/Segmentation/Algorithms/mitkContourModelSetToImageFilter.cpp
@@ -1,273 +1,271 @@
 /*============================================================================
 
 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 "mitkContourModelSetToImageFilter.h"
 
 #include <mitkContourModelSet.h>
 #include <mitkContourModelUtils.h>
 #include <mitkExtractSliceFilter.h>
 #include <mitkImageWriteAccessor.h>
 #include <mitkProgressBar.h>
 #include <mitkTimeHelper.h>
 
 #include <mitkVtkImageOverwrite.h>
 
 mitk::ContourModelSetToImageFilter::ContourModelSetToImageFilter()
   : m_MakeOutputBinary(true), m_TimeStep(0), m_ReferenceImage(nullptr)
 {
   // Create the output.
   itk::DataObject::Pointer output = this->MakeOutput(0);
   Superclass::SetNumberOfRequiredInputs(1);
   Superclass::SetNumberOfRequiredOutputs(1);
   Superclass::SetNthOutput(0, output);
 }
 
 mitk::ContourModelSetToImageFilter::~ContourModelSetToImageFilter()
 {
 }
 
 void mitk::ContourModelSetToImageFilter::GenerateInputRequestedRegion()
 {
   mitk::Image *output = this->GetOutput();
   if ((output->IsInitialized() == false))
     return;
 
   GenerateTimeInInputRegion(output, const_cast<mitk::Image *>(m_ReferenceImage));
 }
 
 void mitk::ContourModelSetToImageFilter::GenerateOutputInformation()
 {
   mitk::Image::Pointer output = this->GetOutput();
 
   itkDebugMacro(<< "GenerateOutputInformation()");
 
   if ((m_ReferenceImage == nullptr) || (m_ReferenceImage->IsInitialized() == false) ||
       (m_ReferenceImage->GetTimeGeometry() == nullptr))
     return;
 
   if (m_MakeOutputBinary)
   {
-    output->Initialize(mitk::MakeScalarPixelType<unsigned char>(), *m_ReferenceImage->GetTimeGeometry(), 1, 1);
+    output->Initialize(mitk::MakeScalarPixelType<unsigned char>(), *m_ReferenceImage->GetTimeGeometry(), 1);
   }
   else
   {
     output->Initialize(m_ReferenceImage->GetPixelType(), *m_ReferenceImage->GetTimeGeometry());
   }
 
   output->SetPropertyList(m_ReferenceImage->GetPropertyList()->Clone());
 }
 
 itk::DataObject::Pointer mitk::ContourModelSetToImageFilter::MakeOutput(DataObjectPointerArraySizeType /*idx*/)
 {
   return OutputType::New().GetPointer();
 }
 
 itk::DataObject::Pointer mitk::ContourModelSetToImageFilter::MakeOutput(const DataObjectIdentifierType &name)
 {
   itkDebugMacro("MakeOutput(" << name << ")");
   if (this->IsIndexedOutputName(name))
   {
     return this->MakeOutput(this->MakeIndexFromOutputName(name));
   }
   return OutputType::New().GetPointer();
 }
 
 const mitk::ContourModelSet *mitk::ContourModelSetToImageFilter::GetInput(void)
 {
   if (this->GetNumberOfInputs() < 1)
   {
     return nullptr;
   }
 
   return static_cast<const mitk::ContourModelSet *>(this->ProcessObject::GetInput(0));
 }
 
 void mitk::ContourModelSetToImageFilter::SetInput(const ContourModelSet *input)
 {
   // Process object is not const-correct so the const_cast is required here
   this->ProcessObject::SetNthInput(0, const_cast<mitk::ContourModelSet *>(input));
 }
 
 void mitk::ContourModelSetToImageFilter::SetImage(const mitk::Image *refImage)
 {
   m_ReferenceImage = refImage;
 }
 
 const mitk::Image *mitk::ContourModelSetToImageFilter::GetImage(void)
 {
   return m_ReferenceImage;
 }
 
 void mitk::ContourModelSetToImageFilter::GenerateData()
 {
   auto *contourSet = const_cast<mitk::ContourModelSet *>(this->GetInput());
 
   // Initializing progressbar
   unsigned int num_contours = contourSet->GetContourModelList()->size();
   mitk::ProgressBar::GetInstance()->AddStepsToDo(num_contours);
 
   // Assure that the volume data of the output is set (fill volume with zeros)
   this->InitializeOutputEmpty();
 
   mitk::Image::Pointer outputImage = const_cast<mitk::Image *>(this->GetOutput());
 
   if (outputImage.IsNull() || outputImage->IsInitialized() == false || !outputImage->IsVolumeSet(m_TimeStep))
   {
-    MITK_ERROR << "Error creating output for specified image!";
-    return;
+    mitkThrow() << "Error creating output for specified image!";
   }
 
   if (!contourSet || contourSet->GetContourModelList()->size() == 0)
   {
-    MITK_ERROR << "No contours specified!";
-    return;
+    mitkThrow() << "No contours specified!";
   }
 
   mitk::BaseGeometry *outputImageGeo = outputImage->GetGeometry(m_TimeStep);
 
   // Create mitkVtkImageOverwrite which is needed to write the slice back into the volume
   vtkSmartPointer<mitkVtkImageOverwrite> reslice = vtkSmartPointer<mitkVtkImageOverwrite>::New();
 
   // Create ExtractSliceFilter for extracting the corresponding slices from the volume
   mitk::ExtractSliceFilter::Pointer extractor = mitk::ExtractSliceFilter::New(reslice);
   extractor->SetInput(outputImage);
   extractor->SetTimeStep(m_TimeStep);
   extractor->SetResliceTransformByGeometry(outputImageGeo);
 
   // Fill each contour of the contourmodelset into the image
   auto it = contourSet->Begin();
   auto end = contourSet->End();
   while (it != end)
   {
     mitk::ContourModel *contour = it->GetPointer();
 
     // 1. Create slice geometry using the contour points
     mitk::PlaneGeometry::Pointer plane = mitk::PlaneGeometry::New();
     mitk::Point3D point3D, tempPoint;
     mitk::Vector3D normal;
 
     mitk::Image::Pointer slice;
 
     int sliceIndex;
     bool isFrontside = true;
     bool isRotated = false;
 
     // Determine plane orientation
     point3D = contour->GetVertexAt(0)->Coordinates;
     tempPoint = contour->GetVertexAt(contour->GetNumberOfVertices() * 0.25)->Coordinates;
     mitk::Vector3D vec = point3D - tempPoint;
     vec.Normalize();
     outputImageGeo->WorldToIndex(point3D, point3D);
 
     mitk::PlaneGeometry::PlaneOrientation orientation;
     if (mitk::Equal(vec[0], 0))
     {
       orientation = mitk::PlaneGeometry::Sagittal;
       sliceIndex = point3D[0];
     }
     else if (mitk::Equal(vec[1], 0))
     {
       orientation = mitk::PlaneGeometry::Frontal;
       sliceIndex = point3D[1];
     }
     else if (mitk::Equal(vec[2], 0))
     {
       orientation = mitk::PlaneGeometry::Axial;
       sliceIndex = point3D[2];
     }
     else
     {
       // TODO Maybe rotate geometry to extract slice?
       MITK_ERROR
         << "Cannot detect correct slice number! Only axial, sagittal and frontal oriented contours are supported!";
       return;
     }
 
     // Initialize plane using the detected orientation
     plane->InitializeStandardPlane(outputImageGeo, orientation, sliceIndex, isFrontside, isRotated);
     point3D = plane->GetOrigin();
     normal = plane->GetNormal();
     normal.Normalize();
     point3D += normal * 0.5; // pixelspacing is 1, so half the spacing is 0.5
     plane->SetOrigin(point3D);
 
     // 2. Extract slice at the given position
     extractor->SetWorldGeometry(plane);
     extractor->SetVtkOutputRequest(false);
     reslice->SetOverwriteMode(false);
 
     extractor->Modified();
     extractor->Update();
 
     slice = extractor->GetOutput();
     slice->DisconnectPipeline();
 
     // 3. Fill contour into slice
     mitk::ContourModel::Pointer projectedContour =
       mitk::ContourModelUtils::ProjectContourTo2DSlice(slice, contour, true, false);
     mitk::ContourModelUtils::FillContourInSlice(projectedContour, slice, outputImage);
 
     // 4. Write slice back into image volume
     reslice->SetInputSlice(slice->GetVtkImageData());
 
     // set overwrite mode to true to write back to the image volume
     reslice->SetOverwriteMode(true);
     reslice->Modified();
 
     extractor->Modified();
     extractor->Update();
 
     reslice->SetInputSlice(nullptr);
 
     // Progress
     mitk::ProgressBar::GetInstance()->Progress();
 
     ++it;
   }
 
   outputImage->Modified();
   outputImage->GetVtkImageData()->Modified();
 }
 
 void mitk::ContourModelSetToImageFilter::InitializeOutputEmpty()
 {
   // Initialize the output's volume with zeros
   mitk::Image *output = this->GetOutput();
   unsigned int byteSize = output->GetPixelType().GetSize();
 
   if (output->GetDimension() < 4)
   {
     for (unsigned int dim = 0; dim < output->GetDimension(); ++dim)
     {
       byteSize *= output->GetDimension(dim);
     }
 
     mitk::ImageWriteAccessor writeAccess(output, output->GetVolumeData(0));
 
     memset(writeAccess.GetData(), 0, byteSize);
   }
   else
   {
     // if we have a time-resolved image we need to set memory to 0 for each time step
     for (unsigned int dim = 0; dim < 3; ++dim)
     {
       byteSize *= output->GetDimension(dim);
     }
 
     for (unsigned int volumeNumber = 0; volumeNumber < output->GetDimension(3); volumeNumber++)
     {
       mitk::ImageWriteAccessor writeAccess(output, output->GetVolumeData(volumeNumber));
 
       memset(writeAccess.GetData(), 0, byteSize);
     }
   }
 }
diff --git a/Modules/Segmentation/SegmentationUtilities/BooleanOperations/mitkBooleanOperation.cpp b/Modules/Segmentation/SegmentationUtilities/BooleanOperations/mitkBooleanOperation.cpp
index 880d00ac5e..6bf2ba52ed 100644
--- a/Modules/Segmentation/SegmentationUtilities/BooleanOperations/mitkBooleanOperation.cpp
+++ b/Modules/Segmentation/SegmentationUtilities/BooleanOperations/mitkBooleanOperation.cpp
@@ -1,185 +1,185 @@
 /*============================================================================
 
 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 "mitkBooleanOperation.h"
 #include <itkAndImageFilter.h>
 #include <itkNotImageFilter.h>
 #include <itkOrImageFilter.h>
 #include <mitkExceptionMacro.h>
 #include <mitkImageCast.h>
 #include <mitkImageTimeSelector.h>
 
 typedef itk::Image<mitk::Label::PixelType, 3> ImageType;
 
-static mitk::Image::Pointer Get3DSegmentation(mitk::Image::Pointer segmentation, unsigned int time)
+static mitk::Image::Pointer Get3DSegmentation(mitk::Image::Pointer segmentation, mitk::TimePointType time)
 {
   if (segmentation->GetDimension() != 4)
     return segmentation;
 
   auto imageTimeSelector = mitk::ImageTimeSelector::New();
   imageTimeSelector->SetInput(segmentation);
-  imageTimeSelector->SetTimeNr(static_cast<int>(time));
+  imageTimeSelector->SetTimeNr(segmentation->GetTimeGeometry()->TimePointToTimeStep(time));
 
   imageTimeSelector->UpdateLargestPossibleRegion();
 
   return imageTimeSelector->GetOutput();
 }
 
-static ImageType::Pointer CastTo3DItkImage(mitk::Image::Pointer segmentation, unsigned int time)
+static ImageType::Pointer CastTo3DItkImage(mitk::Image::Pointer segmentation, mitk::TimePointType time)
 {
   ImageType::Pointer result;
   mitk::CastToItkImage(Get3DSegmentation(segmentation, time), result);
   return result;
 }
 
 mitk::BooleanOperation::BooleanOperation(Type type,
                                          mitk::Image::Pointer segmentationA,
                                          mitk::Image::Pointer segmentationB,
-                                         unsigned int time)
-  : m_Type(type), m_SegmentationA(segmentationA), m_SegmentationB(segmentationB), m_Time(time)
+                                         TimePointType time)
+  : m_Type(type), m_SegmentationA(segmentationA), m_SegmentationB(segmentationB), m_TimePoint(time)
 {
   this->ValidateSegmentations();
 }
 
 mitk::BooleanOperation::~BooleanOperation()
 {
 }
 
 mitk::LabelSetImage::Pointer mitk::BooleanOperation::GetResult() const
 {
   switch (m_Type)
   {
     case Difference:
       return this->GetDifference();
 
     case Intersection:
       return this->GetIntersection();
 
     case Union:
       return this->GetUnion();
 
     default:
       mitkThrow() << "Unknown boolean operation type '" << m_Type << "'!";
   }
 }
 
 mitk::LabelSetImage::Pointer mitk::BooleanOperation::GetDifference() const
 {
-  auto input1 = CastTo3DItkImage(m_SegmentationA, m_Time);
-  auto input2 = CastTo3DItkImage(m_SegmentationB, m_Time);
+  auto input1 = CastTo3DItkImage(m_SegmentationA, m_TimePoint);
+  auto input2 = CastTo3DItkImage(m_SegmentationB, m_TimePoint);
 
   auto notFilter = itk::NotImageFilter<ImageType, ImageType>::New();
   notFilter->SetInput(input2);
 
   auto andFilter = itk::AndImageFilter<ImageType, ImageType>::New();
   andFilter->SetInput1(input1);
   andFilter->SetInput2(notFilter->GetOutput());
 
   andFilter->UpdateLargestPossibleRegion();
 
   auto tempResult = Image::New();
   CastToMitkImage<ImageType>(andFilter->GetOutput(), tempResult);
 
   tempResult->DisconnectPipeline();
 
   auto result = mitk::LabelSetImage::New();
   result->InitializeByLabeledImage(tempResult);
 
   return result;
 }
 
 mitk::LabelSetImage::Pointer mitk::BooleanOperation::GetIntersection() const
 {
-  auto input1 = CastTo3DItkImage(m_SegmentationA, m_Time);
-  auto input2 = CastTo3DItkImage(m_SegmentationB, m_Time);
+  auto input1 = CastTo3DItkImage(m_SegmentationA, m_TimePoint);
+  auto input2 = CastTo3DItkImage(m_SegmentationB, m_TimePoint);
 
   auto andFilter = itk::AndImageFilter<ImageType, ImageType>::New();
   andFilter->SetInput1(input1);
   andFilter->SetInput2(input2);
 
   andFilter->UpdateLargestPossibleRegion();
 
   auto tempResult = Image::New();
   CastToMitkImage<ImageType>(andFilter->GetOutput(), tempResult);
 
   tempResult->DisconnectPipeline();
 
   auto result = mitk::LabelSetImage::New();
   result->InitializeByLabeledImage(tempResult);
 
   return result;
 }
 
 mitk::LabelSetImage::Pointer mitk::BooleanOperation::GetUnion() const
 {
-  auto input1 = CastTo3DItkImage(m_SegmentationA, m_Time);
-  auto input2 = CastTo3DItkImage(m_SegmentationB, m_Time);
+  auto input1 = CastTo3DItkImage(m_SegmentationA, m_TimePoint);
+  auto input2 = CastTo3DItkImage(m_SegmentationB, m_TimePoint);
 
   auto orFilter = itk::OrImageFilter<ImageType, ImageType>::New();
   orFilter->SetInput1(input1);
   orFilter->SetInput2(input2);
 
   orFilter->UpdateLargestPossibleRegion();
 
   auto tempResult = Image::New();
   CastToMitkImage<ImageType>(orFilter->GetOutput(), tempResult);
 
   tempResult->DisconnectPipeline();
 
   auto result = mitk::LabelSetImage::New();
   result->InitializeByLabeledImage(tempResult);
 
   return result;
 }
 
 void mitk::BooleanOperation::ValidateSegmentation(mitk::Image::Pointer segmentation) const
 {
   if (segmentation.IsNull())
     mitkThrow() << "Segmentation is nullptr!";
 
   if (segmentation->GetImageDescriptor()->GetNumberOfChannels() != 1)
     mitkThrow() << "Segmentation has more than one channel!";
 
   auto pixelType = segmentation->GetImageDescriptor()->GetChannelDescriptor().GetPixelType();
 
   if (pixelType.GetPixelType() != itk::ImageIOBase::SCALAR ||
       (pixelType.GetComponentType() != itk::ImageIOBase::UCHAR &&
        pixelType.GetComponentType() != itk::ImageIOBase::USHORT))
     mitkThrow() << "Segmentation is neither of type 'unsigned char' nor type 'unsigned short'!";
 
   auto dimension = segmentation->GetDimension();
 
   if (dimension > 4)
     mitkThrow() << "Segmentation has more than four dimensions!";
 
-  if (m_Time != 0)
-  {
-    if (dimension < 4)
-      mitkThrow() << "Expected four-dimensional segmentation!";
-
-    if (segmentation->GetDimension(3) < m_Time)
-      mitkThrow() << "Extent of fourth dimension of segmentation is less than specified time!";
-  }
-  else if (dimension < 3)
-  {
+  if (dimension < 3)
     mitkThrow() << "Segmentation has less than three dimensions!";
-  }
+
+  if (!segmentation->GetTimeGeometry()->IsValidTimePoint(m_TimePoint))
+    mitkThrow() << "Segmentation is not defined for specified time point. Time point: " << m_TimePoint;
 }
 
 void mitk::BooleanOperation::ValidateSegmentations() const
 {
   this->ValidateSegmentation(m_SegmentationA);
   this->ValidateSegmentation(m_SegmentationB);
 
   if (m_SegmentationA->GetDimension() != m_SegmentationB->GetDimension())
     mitkThrow() << "Segmentations have different dimensions!";
+
+  const auto geometryA = m_SegmentationA->GetTimeGeometry()->GetGeometryForTimePoint(m_TimePoint);
+  const auto geometryB = m_SegmentationB->GetTimeGeometry()->GetGeometryForTimePoint(m_TimePoint);
+  if (!mitk::Equal(*(geometryA.GetPointer()), *(geometryB.GetPointer()),eps,false))
+  {
+    mitkThrow() << "Segmentations have different geometries and cannot be used for boolean operations!";
+  }
 }
diff --git a/Modules/Segmentation/SegmentationUtilities/BooleanOperations/mitkBooleanOperation.h b/Modules/Segmentation/SegmentationUtilities/BooleanOperations/mitkBooleanOperation.h
index 5fc6858c52..8822957cd2 100644
--- a/Modules/Segmentation/SegmentationUtilities/BooleanOperations/mitkBooleanOperation.h
+++ b/Modules/Segmentation/SegmentationUtilities/BooleanOperations/mitkBooleanOperation.h
@@ -1,73 +1,73 @@
 /*============================================================================
 
 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 mitkBooleanOperation_h
 #define mitkBooleanOperation_h
 
 #include <MitkSegmentationExports.h>
 #include <mitkLabelSetImage.h>
 
 namespace mitk
 {
   /** \brief Executes a boolean operation on two different segmentations.
    *
    * All parameters of the boolean operations must be specified during construction.
    * The actual operation is executed when calling GetResult().
    */
   class MITKSEGMENTATION_EXPORT BooleanOperation
   {
   public:
     enum Type
     {
       None,
       Difference,
       Intersection,
       Union
     };
 
     /* \brief Construct a boolean operation.
      *
      * Throws an mitk::Exception when segmentations are somehow invalid.
      *
      * \param[in] type The type of the boolean operation.
      * \param[in] segmentationA The first operand of the boolean operation.
      * \param[in] segmentationB The second operand of the boolean operation.
-     * \param[in] The time step at which the operation will be executed.
+     * \param[in] The time point at which the operation will be executed.
      */
-    BooleanOperation(Type type, Image::Pointer segmentationA, Image::Pointer segmentationB, unsigned int time = 0);
+    BooleanOperation(Type type, Image::Pointer segmentationA, Image::Pointer segmentationB, TimePointType time = 0.);
     ~BooleanOperation();
 
     /* \brief Execute boolean operation and return resulting segmentation.
      *
      * \return The resulting segmentation.
      */
     LabelSetImage::Pointer GetResult() const;
 
   private:
     BooleanOperation(const BooleanOperation &);
     BooleanOperation &operator=(const BooleanOperation &);
 
     LabelSetImage::Pointer GetDifference() const;
     LabelSetImage::Pointer GetIntersection() const;
     LabelSetImage::Pointer GetUnion() const;
 
     void ValidateSegmentation(Image::Pointer segmentation) const;
     void ValidateSegmentations() const;
 
     Type m_Type;
     Image::Pointer m_SegmentationA;
     Image::Pointer m_SegmentationB;
-    unsigned int m_Time;
+    TimePointType m_TimePoint;
   };
 }
 
 #endif
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/BooleanOperations/QmitkBooleanOperationsWidget.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/BooleanOperations/QmitkBooleanOperationsWidget.cpp
index 64c496cda8..87c10cacf2 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/BooleanOperations/QmitkBooleanOperationsWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/SegmentationUtilities/BooleanOperations/QmitkBooleanOperationsWidget.cpp
@@ -1,140 +1,140 @@
 /*============================================================================
 
 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 "QmitkBooleanOperationsWidget.h"
 #include "../../Common/QmitkDataSelectionWidget.h"
 #include <mitkException.h>
 #include <mitkSliceNavigationController.h>
 #include <cassert>
 
 static const char* const HelpText = "Select two different masks above";
 
 std::string GetPrefix(mitk::BooleanOperation::Type type)
 {
   switch (type)
   {
     case mitk::BooleanOperation::Difference:
       return "DifferenceFrom_";
 
     case mitk::BooleanOperation::Intersection:
       return "IntersectionWith_";
 
     case mitk::BooleanOperation::Union:
       return "UnionWith_";
 
     default:
       assert(false && "Unknown boolean operation type");
       return "UNKNOWN_BOOLEAN_OPERATION_WITH_";
   }
 }
 
 void AddToDataStorage(mitk::DataStorage::Pointer dataStorage, mitk::Image::Pointer segmentation, const std::string& name, mitk::DataNode::Pointer parent = nullptr)
 {
   mitk::DataNode::Pointer dataNode = mitk::DataNode::New();
 
   dataNode->SetBoolProperty("binary", true);
   dataNode->SetName(name);
   dataNode->SetData(segmentation);
 
   dataStorage->Add(dataNode, parent);
 }
 
 QmitkBooleanOperationsWidget::QmitkBooleanOperationsWidget(mitk::SliceNavigationController* timeNavigationController, QWidget* parent)
   : QmitkSegmentationUtilityWidget(timeNavigationController, parent)
 {
   m_Controls.setupUi(this);
 
   m_Controls.dataSelectionWidget->AddDataSelection(QmitkDataSelectionWidget::MaskPredicate);
   m_Controls.dataSelectionWidget->AddDataSelection(QmitkDataSelectionWidget::MaskPredicate);
 
   m_Controls.dataSelectionWidget->SetHelpText(HelpText);
 
   connect(m_Controls.dataSelectionWidget, SIGNAL(SelectionChanged(unsigned int, const mitk::DataNode*)), this, SLOT(OnSelectionChanged(unsigned int, const mitk::DataNode*)));
   connect(m_Controls.differenceButton, SIGNAL(clicked()), this, SLOT(OnDifferenceButtonClicked()));
   connect(m_Controls.intersectionButton, SIGNAL(clicked()), this, SLOT(OnIntersectionButtonClicked()));
   connect(m_Controls.unionButton, SIGNAL(clicked()), this, SLOT(OnUnionButtonClicked()));
 }
 
 QmitkBooleanOperationsWidget::~QmitkBooleanOperationsWidget()
 {
 }
 
 void QmitkBooleanOperationsWidget::OnSelectionChanged(unsigned int, const mitk::DataNode*)
 {
   QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
 
   mitk::DataNode::Pointer node0 = dataSelectionWidget->GetSelection(0);
   mitk::DataNode::Pointer node1 = dataSelectionWidget->GetSelection(1);
 
   if (node0.IsNotNull() && node1.IsNotNull() && node0 != node1)
   {
     dataSelectionWidget->SetHelpText("");
     this->EnableButtons();
   }
   else
   {
     dataSelectionWidget->SetHelpText(HelpText);
     this->EnableButtons(false);
   }
 }
 
 void QmitkBooleanOperationsWidget::EnableButtons(bool enable)
 {
   m_Controls.differenceButton->setEnabled(enable);
   m_Controls.intersectionButton->setEnabled(enable);
   m_Controls.unionButton->setEnabled(enable);
 }
 
 void QmitkBooleanOperationsWidget::OnDifferenceButtonClicked()
 {
   this->DoBooleanOperation(mitk::BooleanOperation::Difference);
 }
 
 void QmitkBooleanOperationsWidget::OnIntersectionButtonClicked()
 {
   this->DoBooleanOperation(mitk::BooleanOperation::Intersection);
 }
 
 void QmitkBooleanOperationsWidget::OnUnionButtonClicked()
 {
   this->DoBooleanOperation(mitk::BooleanOperation::Union);
 }
 
 void QmitkBooleanOperationsWidget::DoBooleanOperation(mitk::BooleanOperation::Type type)
 {
   mitk::SliceNavigationController* timeNavigationController = this->GetTimeNavigationController();
   assert(timeNavigationController != nullptr);
 
   mitk::Image::Pointer segmentation0 = static_cast<mitk::Image*>(m_Controls.dataSelectionWidget->GetSelection(0)->GetData());
   mitk::Image::Pointer segmentation1 = static_cast<mitk::Image*>(m_Controls.dataSelectionWidget->GetSelection(1)->GetData());
   mitk::Image::Pointer result;
 
   try
   {
-    mitk::BooleanOperation booleanOperation(type, segmentation0, segmentation1, timeNavigationController->GetTime()->GetPos());
+    mitk::BooleanOperation booleanOperation(type, segmentation0, segmentation1, timeNavigationController->GetSelectedTimePoint());
     result = booleanOperation.GetResult();
   }
   catch (const mitk::Exception &exception)
   {
     MITK_ERROR << "Boolean operation failed: " << exception.GetDescription();
   }
 
   assert(result.IsNotNull());
 
   QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
 
   AddToDataStorage(
     dataSelectionWidget->GetDataStorage(),
     result,
     GetPrefix(type) + dataSelectionWidget->GetSelection(1)->GetName(),
     dataSelectionWidget->GetSelection(0));
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/BooleanOperations/QmitkBooleanOperationsWidget.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/BooleanOperations/QmitkBooleanOperationsWidget.cpp
index d66b78dc14..abb337ba5b 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/BooleanOperations/QmitkBooleanOperationsWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/BooleanOperations/QmitkBooleanOperationsWidget.cpp
@@ -1,141 +1,141 @@
 /*============================================================================
 
 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 "QmitkBooleanOperationsWidget.h"
 #include "../../Common/QmitkDataSelectionWidget.h"
 #include <mitkException.h>
 #include <mitkSliceNavigationController.h>
 #include <cassert>
 #include <QMessageBox>
 
 static const char* const HelpText = "Select two different segmentations above";
 
 static std::string GetPrefix(mitk::BooleanOperation::Type type)
 {
   switch (type)
   {
     case mitk::BooleanOperation::Difference:
       return "DifferenceFrom_";
 
     case mitk::BooleanOperation::Intersection:
       return "IntersectionWith_";
 
     case mitk::BooleanOperation::Union:
       return "UnionWith_";
 
     default:
       assert(false && "Unknown boolean operation type");
       return "UNKNOWN_BOOLEAN_OPERATION_WITH_";
   }
 }
 
 static void AddToDataStorage(mitk::DataStorage::Pointer dataStorage, mitk::Image::Pointer segmentation, const std::string& name, mitk::DataNode::Pointer parent = nullptr)
 {
   auto dataNode = mitk::DataNode::New();
 
   dataNode->SetName(name);
   dataNode->SetData(segmentation);
 
   dataStorage->Add(dataNode, parent);
 }
 
 QmitkBooleanOperationsWidget::QmitkBooleanOperationsWidget(mitk::SliceNavigationController* timeNavigationController, QWidget* parent)
   : QmitkSegmentationUtilityWidget(timeNavigationController, parent)
 {
   m_Controls.setupUi(this);
 
   m_Controls.dataSelectionWidget->AddDataSelection("<img width=16 height=16 src=\":/SegmentationUtilities/BooleanLabelA_32x32.png\"/>", "Select 1st segmentation", "Select 1st segmentation", "", QmitkDataSelectionWidget::SegmentationPredicate);
   m_Controls.dataSelectionWidget->AddDataSelection("<img width=16 height=16 src=\":/SegmentationUtilities/BooleanLabelB_32x32.png\"/>", "Select 2nd segmentation", "Select 2nd segmentation", "", QmitkDataSelectionWidget::SegmentationPredicate);
 
   m_Controls.dataSelectionWidget->SetHelpText(HelpText);
 
   connect(m_Controls.dataSelectionWidget, SIGNAL(SelectionChanged(unsigned int, const mitk::DataNode*)), this, SLOT(OnSelectionChanged(unsigned int, const mitk::DataNode*)));
   connect(m_Controls.differenceButton, SIGNAL(clicked()), this, SLOT(OnDifferenceButtonClicked()));
   connect(m_Controls.intersectionButton, SIGNAL(clicked()), this, SLOT(OnIntersectionButtonClicked()));
   connect(m_Controls.unionButton, SIGNAL(clicked()), this, SLOT(OnUnionButtonClicked()));
 }
 
 QmitkBooleanOperationsWidget::~QmitkBooleanOperationsWidget()
 {
 }
 
 void QmitkBooleanOperationsWidget::OnSelectionChanged(unsigned int, const mitk::DataNode*)
 {
   auto dataSelectionWidget = m_Controls.dataSelectionWidget;
 
   auto nodeA = dataSelectionWidget->GetSelection(0);
   auto nodeB = dataSelectionWidget->GetSelection(1);
 
   if (nodeA.IsNotNull() && nodeB.IsNotNull() && nodeA != nodeB)
   {
     dataSelectionWidget->SetHelpText("");
     this->EnableButtons();
   }
   else
   {
     dataSelectionWidget->SetHelpText(HelpText);
     this->EnableButtons(false);
   }
 }
 
 void QmitkBooleanOperationsWidget::EnableButtons(bool enable)
 {
   m_Controls.differenceButton->setEnabled(enable);
   m_Controls.intersectionButton->setEnabled(enable);
   m_Controls.unionButton->setEnabled(enable);
 }
 
 void QmitkBooleanOperationsWidget::OnDifferenceButtonClicked()
 {
   this->DoBooleanOperation(mitk::BooleanOperation::Difference);
 }
 
 void QmitkBooleanOperationsWidget::OnIntersectionButtonClicked()
 {
   this->DoBooleanOperation(mitk::BooleanOperation::Intersection);
 }
 
 void QmitkBooleanOperationsWidget::OnUnionButtonClicked()
 {
   this->DoBooleanOperation(mitk::BooleanOperation::Union);
 }
 
 void QmitkBooleanOperationsWidget::DoBooleanOperation(mitk::BooleanOperation::Type type)
 {
   auto timeNavigationController = this->GetTimeNavigationController();
   assert(timeNavigationController != nullptr);
 
   mitk::Image::Pointer segmentationA = dynamic_cast<mitk::Image*>(m_Controls.dataSelectionWidget->GetSelection(0)->GetData());
   mitk::Image::Pointer segmentationB = dynamic_cast<mitk::Image*>(m_Controls.dataSelectionWidget->GetSelection(1)->GetData());
   mitk::Image::Pointer result;
 
   try
   {
-    mitk::BooleanOperation booleanOperation(type, segmentationA, segmentationB, timeNavigationController->GetTime()->GetPos());
+    mitk::BooleanOperation booleanOperation(type, segmentationA, segmentationB, timeNavigationController->GetSelectedTimePoint());
     result = booleanOperation.GetResult();
 
     assert(result.IsNotNull());
 
     auto dataSelectionWidget = m_Controls.dataSelectionWidget;
 
     AddToDataStorage(
       dataSelectionWidget->GetDataStorage(),
       result,
       GetPrefix(type) + dataSelectionWidget->GetSelection(1)->GetName(),
       dataSelectionWidget->GetSelection(0));
   }
   catch (const mitk::Exception& exception)
   {
     MITK_ERROR << "Boolean operation failed: " << exception.GetDescription();
     QMessageBox::information(nullptr, "Boolean operation failed", exception.GetDescription());
   }
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/ContourModelToImage/QmitkContourModelToImageWidget.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/ContourModelToImage/QmitkContourModelToImageWidget.cpp
index eb5efa0705..59ff902954 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/ContourModelToImage/QmitkContourModelToImageWidget.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/SegmentationUtilities/ContourModelToImage/QmitkContourModelToImageWidget.cpp
@@ -1,226 +1,245 @@
 /*============================================================================
 
 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 "QmitkContourModelToImageWidget.h"
 #include "mitkImage.h"
 #include "../../Common/QmitkDataSelectionWidget.h"
 
 #include <mitkContourModelSet.h>
 #include <mitkContourModelSetToImageFilter.h>
 #include <mitkSliceNavigationController.h>
 
 #include <QtConcurrentRun>
 #include <QFuture>
 #include <QFutureWatcher>
 #include <qmessagebox.h>
 
 static const char* const HelpText = "Select a image and a contour(set)";
 
 class QmitkContourModelToImageWidgetPrivate
 {
 public:
   QmitkContourModelToImageWidgetPrivate();
   ~QmitkContourModelToImageWidgetPrivate();
 
   /** @brief Check if selections is valid. */
   void SelectionControl( unsigned int index, const mitk::DataNode* selection);
 
   /** @brief Enable buttons if data selction is valid. */
   void EnableButtons(bool enable = true);
 
   /** @brief Does the actual contour filling */
-  mitk::Image::Pointer FillContourModelSetIntoImage(mitk::Image *image, mitk::ContourModelSet *contourSet, unsigned int timeStep);
+  mitk::Image::Pointer FillContourModelSetIntoImage(mitk::Image *image, mitk::ContourModelSet *contourSet, mitk::TimePointType timePoint);
 
   Ui::QmitkContourModelToImageWidgetControls m_Controls;
   QFutureWatcher<mitk::Image::Pointer> m_Watcher;
 };
 
 QmitkContourModelToImageWidgetPrivate::QmitkContourModelToImageWidgetPrivate()
 {
 }
 
 QmitkContourModelToImageWidgetPrivate::~QmitkContourModelToImageWidgetPrivate()
 {
 }
 
 void QmitkContourModelToImageWidgetPrivate::EnableButtons(bool enable)
 {
   m_Controls.btnProcess->setEnabled(enable);
 }
 
 void QmitkContourModelToImageWidgetPrivate::SelectionControl(unsigned int index, const mitk::DataNode* /*selection*/)
 {
   QmitkDataSelectionWidget* dataSelectionWidget = m_Controls.dataSelectionWidget;
   mitk::DataNode::Pointer node = dataSelectionWidget->GetSelection(index);
 
   dataSelectionWidget->SetHelpText("");
   this->EnableButtons();
 }
 
-mitk::Image::Pointer QmitkContourModelToImageWidgetPrivate::FillContourModelSetIntoImage(mitk::Image* image, mitk::ContourModelSet* contourSet, unsigned int timeStep)
+mitk::Image::Pointer QmitkContourModelToImageWidgetPrivate::FillContourModelSetIntoImage(mitk::Image* image, mitk::ContourModelSet* contourSet, mitk::TimePointType timePoint)
 {
   // Use mitk::ContourModelSetToImageFilter to fill the ContourModelSet into the image
   mitk::ContourModelSetToImageFilter::Pointer contourFiller = mitk::ContourModelSetToImageFilter::New();
+  auto timeStep = image->GetTimeGeometry()->TimePointToTimeStep(timePoint);
   contourFiller->SetTimeStep(timeStep);
   contourFiller->SetImage(image);
   contourFiller->SetInput(contourSet);
   contourFiller->MakeOutputBinaryOn();
-  contourFiller->Update();
+  mitk::Image::Pointer result = nullptr;
+
+  try
+  {
+    contourFiller->Update();
+    result = contourFiller->GetOutput();
+  }
+  catch (const std::exception & e)
+  {
+    MITK_ERROR << "Error while converting contour model. "<< e.what();
+  }
+  catch (...)
+  {
+    MITK_ERROR << "Unknown error while converting contour model.";
+  }
 
-  mitk::Image::Pointer result = contourFiller->GetOutput();
   if (result.IsNull())
   {
     MITK_ERROR<<"Could not write the selected contours into the image!";
   }
 
   result->DisconnectPipeline();
   return result;
 }
 
 void QmitkContourModelToImageWidget::OnSelectionChanged(unsigned int index, const mitk::DataNode* selection)
 {
   Q_D(QmitkContourModelToImageWidget);
   QmitkDataSelectionWidget* dataSelectionWidget = d->m_Controls.dataSelectionWidget;
   mitk::DataNode::Pointer node0 = dataSelectionWidget->GetSelection(0);
   mitk::DataNode::Pointer node1 = dataSelectionWidget->GetSelection(1);
 
   if (node0.IsNull() || node1.IsNull() )
   {
     d->EnableButtons(false);
     dataSelectionWidget->SetHelpText(HelpText);
   }
   else
   {
     d->SelectionControl(index, selection);
   }
 }
 
 void QmitkContourModelToImageWidget::OnProcessingFinished()
 {
   // Called when processing finished
   // Adding the result to the data storage
 
   Q_D(QmitkContourModelToImageWidget);
 
   // Adding the result to the data storage
   mitk::Image::Pointer result = d->m_Watcher.result();
   if (result.IsNotNull())
   {
     QmitkDataSelectionWidget* dataSelectionWidget = d->m_Controls.dataSelectionWidget;
     mitk::DataNode::Pointer imageNode = dataSelectionWidget->GetSelection(0);
     mitk::DataNode::Pointer contourNode = dataSelectionWidget->GetSelection(1);
 
     mitk::DataNode::Pointer filled = mitk::DataNode::New();
     std::stringstream stream;
     stream << imageNode->GetName();
     stream << "_";
     stream << contourNode->GetName();
     filled->SetName(stream.str());
     filled->SetData(result);
 
     dataSelectionWidget->GetDataStorage()->Add(filled, imageNode);
     mitk::RenderingManager::GetInstance()->RequestUpdateAll();
   }
   else
   {
     MITK_ERROR<<"Error filling contours into an image!";
   }
 
   d->EnableButtons();
 }
 
 void QmitkContourModelToImageWidget::OnProcessPressed()
 {
   Q_D(QmitkContourModelToImageWidget);
 
   QmitkDataSelectionWidget* dataSelectionWidget = d->m_Controls.dataSelectionWidget;
 
   mitk::DataNode::Pointer imageNode = dataSelectionWidget->GetSelection(0);
   mitk::DataNode::Pointer contourNode = dataSelectionWidget->GetSelection(1);
 
   // Check if data nodes are valid
   if(imageNode.IsNull() || contourNode.IsNull() )
   {
     MITK_ERROR << "Selection does not contain valid data";
     QMessageBox::information( this, "Contour To Image",
                               "Selection does not contain valid data, please select a binary image and a contour(set)",
                               QMessageBox::Ok );
     d->m_Controls.btnProcess->setEnabled(false);
     return;
   }
 
   mitk::Image::Pointer image = static_cast<mitk::Image*>(imageNode->GetData());
 
   // Check if the image is valid
   if (image.IsNull())
   {
     MITK_ERROR<<"Error writing contours into image! Invalid image data selected!";
     return;
   }
 
-  unsigned int timeStep = this->GetTimeNavigationController()->GetTime()->GetPos();
+  const auto timePoint = this->GetTimeNavigationController()->GetSelectedTimePoint();
+  if (!image->GetTimeGeometry()->IsValidTimePoint(timePoint))
+  {
+    MITK_ERROR << "Error writing contours into image! Currently selected time point is not supported by selected image data.";
+    return;
+  }
 
   // Check if the selected contours are valid
   mitk::ContourModelSet::Pointer contourSet;
   mitk::ContourModel::Pointer contour = dynamic_cast<mitk::ContourModel*>(contourNode->GetData());
   if (contour.IsNotNull())
   {
     contourSet = mitk::ContourModelSet::New();
     contourSet->AddContourModel(contour);
   }
   else
   {
     contourSet = static_cast<mitk::ContourModelSet*>(contourNode->GetData());
     if (contourSet.IsNull())
     {
       MITK_ERROR<<"Error writing contours into binary image! Invalid contour data selected!";
       return;
     }
   }
 
   //Disable Buttons during calculation and initialize Progressbar
   d->EnableButtons(false);
 
   // Start the computation in a background thread
-  QFuture< mitk::Image::Pointer > future = QtConcurrent::run(d, &QmitkContourModelToImageWidgetPrivate::FillContourModelSetIntoImage, image, contourSet, timeStep);
+  QFuture< mitk::Image::Pointer > future = QtConcurrent::run(d, &QmitkContourModelToImageWidgetPrivate::FillContourModelSetIntoImage, image, contourSet, timePoint);
   d->m_Watcher.setFuture(future);
 }
 
 QmitkContourModelToImageWidget::QmitkContourModelToImageWidget(mitk::SliceNavigationController* timeNavigationController, QWidget* parent)
   : QmitkSegmentationUtilityWidget(timeNavigationController, parent),
     d_ptr(new QmitkContourModelToImageWidgetPrivate())
 {
   Q_D(QmitkContourModelToImageWidget);
 
   // Set up UI
   d->m_Controls.setupUi(this);
   d->m_Controls.dataSelectionWidget->AddDataSelection(QmitkDataSelectionWidget::ImageAndSegmentationPredicate);
   d->m_Controls.dataSelectionWidget->AddDataSelection(QmitkDataSelectionWidget::ContourModelPredicate);
   d->m_Controls.dataSelectionWidget->SetHelpText(HelpText);
   d->EnableButtons(false);
 
   // Create connections
   connect (d->m_Controls.btnProcess, SIGNAL(pressed()), this, SLOT(OnProcessPressed()));
   connect(d->m_Controls.dataSelectionWidget, SIGNAL(SelectionChanged(unsigned int, const mitk::DataNode*)),
           this, SLOT(OnSelectionChanged(unsigned int, const mitk::DataNode*)));
   connect(&d->m_Watcher, SIGNAL(finished()), this, SLOT(OnProcessingFinished()));
 
   if( d->m_Controls.dataSelectionWidget->GetSelection(0).IsNotNull() &&
       d->m_Controls.dataSelectionWidget->GetSelection(1).IsNotNull() )
   {
     OnSelectionChanged(0, d->m_Controls.dataSelectionWidget->GetSelection(0));
   }
 }
 
 QmitkContourModelToImageWidget::~QmitkContourModelToImageWidget()
 {
 }