diff --git a/Modules/Core/files.cmake b/Modules/Core/files.cmake
index 75407c5ac8..3178dddf16 100644
--- a/Modules/Core/files.cmake
+++ b/Modules/Core/files.cmake
@@ -1,325 +1,326 @@
 file(GLOB_RECURSE H_FILES RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}/include/*")
 
 set(CPP_FILES
   mitkCoreActivator.cpp
   mitkCoreObjectFactoryBase.cpp
   mitkCoreObjectFactory.cpp
   mitkCoreServices.cpp
   mitkException.cpp
 
   Algorithms/mitkBaseDataSource.cpp
   Algorithms/mitkClippedSurfaceBoundsCalculator.cpp
   Algorithms/mitkCompareImageDataFilter.cpp
   Algorithms/mitkCompositePixelValueToString.cpp
   Algorithms/mitkConvert2Dto3DImageFilter.cpp
   Algorithms/mitkDataNodeSource.cpp
   Algorithms/mitkExtractSliceFilter.cpp
   Algorithms/mitkExtractSliceFilter2.cpp
   Algorithms/mitkHistogramGenerator.cpp
   Algorithms/mitkImageChannelSelector.cpp
   Algorithms/mitkImageSliceSelector.cpp
   Algorithms/mitkImageSource.cpp
   Algorithms/mitkImageTimeSelector.cpp
   Algorithms/mitkImageToImageFilter.cpp
   Algorithms/mitkImageToSurfaceFilter.cpp
   Algorithms/mitkMultiComponentImageDataComparisonFilter.cpp
   Algorithms/mitkPlaneGeometryDataToSurfaceFilter.cpp
   Algorithms/mitkPointSetSource.cpp
   Algorithms/mitkPointSetToPointSetFilter.cpp
   Algorithms/mitkRGBToRGBACastImageFilter.cpp
   Algorithms/mitkSubImageSelector.cpp
   Algorithms/mitkSurfaceSource.cpp
   Algorithms/mitkSurfaceToImageFilter.cpp
   Algorithms/mitkSurfaceToSurfaceFilter.cpp
   Algorithms/mitkUIDGenerator.cpp
   Algorithms/mitkVolumeCalculator.cpp
   Algorithms/mitkTemporalJoinImagesFilter.cpp
 
   Controllers/mitkBaseController.cpp
   Controllers/mitkCallbackFromGUIThread.cpp
   Controllers/mitkCameraController.cpp
   Controllers/mitkCameraRotationController.cpp
   Controllers/mitkLimitedLinearUndo.cpp
   Controllers/mitkOperationEvent.cpp
   Controllers/mitkPlanePositionManager.cpp
   Controllers/mitkProgressBar.cpp
   Controllers/mitkRenderingManager.cpp
   Controllers/mitkSliceNavigationController.cpp
   Controllers/mitkSlicesCoordinator.cpp
   Controllers/mitkStatusBar.cpp
   Controllers/mitkStepper.cpp
   Controllers/mitkTestManager.cpp
   Controllers/mitkUndoController.cpp
   Controllers/mitkVerboseLimitedLinearUndo.cpp
   Controllers/mitkVtkLayerController.cpp
   DataManagement/mitkAnatomicalStructureColorPresets.cpp
   DataManagement/mitkArbitraryTimeGeometry.cpp
   DataManagement/mitkAbstractTransformGeometry.cpp
   DataManagement/mitkAnnotationProperty.cpp
   DataManagement/mitkApplicationCursor.cpp
   DataManagement/mitkApplyTransformMatrixOperation.cpp
   DataManagement/mitkBaseData.cpp
   DataManagement/mitkBaseGeometry.cpp
   DataManagement/mitkBaseProperty.cpp
   DataManagement/mitkChannelDescriptor.cpp
   DataManagement/mitkClippingProperty.cpp
   DataManagement/mitkColorProperty.cpp
   DataManagement/mitkDataNode.cpp
   DataManagement/mitkDataStorage.cpp
   DataManagement/mitkEnumerationProperty.cpp
   DataManagement/mitkFloatPropertyExtension.cpp
   DataManagement/mitkGeometry3D.cpp
   DataManagement/mitkGeometryData.cpp
   DataManagement/mitkGeometryTransformHolder.cpp
   DataManagement/mitkGroupTagProperty.cpp
   DataManagement/mitkGenericIDRelationRule.cpp
   DataManagement/mitkIdentifiable.cpp
   DataManagement/mitkImageAccessorBase.cpp
   DataManagement/mitkImageCaster.cpp
   DataManagement/mitkImageCastPart1.cpp
   DataManagement/mitkImageCastPart2.cpp
   DataManagement/mitkImageCastPart3.cpp
   DataManagement/mitkImageCastPart4.cpp
   DataManagement/mitkImage.cpp
   DataManagement/mitkImageDataItem.cpp
   DataManagement/mitkImageDescriptor.cpp
   DataManagement/mitkImageReadAccessor.cpp
   DataManagement/mitkImageStatisticsHolder.cpp
   DataManagement/mitkImageVtkAccessor.cpp
   DataManagement/mitkImageVtkReadAccessor.cpp
   DataManagement/mitkImageVtkWriteAccessor.cpp
   DataManagement/mitkImageWriteAccessor.cpp
   DataManagement/mitkIntPropertyExtension.cpp
   DataManagement/mitkIPersistenceService.cpp
   DataManagement/mitkIPropertyAliases.cpp
   DataManagement/mitkIPropertyDescriptions.cpp
   DataManagement/mitkIPropertyExtensions.cpp
   DataManagement/mitkIPropertyFilters.cpp
   DataManagement/mitkIPropertyOwner.cpp
   DataManagement/mitkIPropertyPersistence.cpp
   DataManagement/mitkIPropertyProvider.cpp
   DataManagement/mitkLandmarkProjectorBasedCurvedGeometry.cpp
   DataManagement/mitkLandmarkProjector.cpp
   DataManagement/mitkLevelWindow.cpp
   DataManagement/mitkLevelWindowManager.cpp
   DataManagement/mitkLevelWindowPreset.cpp
   DataManagement/mitkLevelWindowProperty.cpp
   DataManagement/mitkLine.cpp
   DataManagement/mitkLookupTable.cpp
   DataManagement/mitkLookupTableProperty.cpp
   DataManagement/mitkLookupTables.cpp # specializations of GenericLookupTable
   DataManagement/mitkMaterial.cpp
   DataManagement/mitkMemoryUtilities.cpp
   DataManagement/mitkModalityProperty.cpp
   DataManagement/mitkModifiedLock.cpp
   DataManagement/mitkNodePredicateAnd.cpp
   DataManagement/mitkNodePredicateBase.cpp
   DataManagement/mitkNodePredicateCompositeBase.cpp
   DataManagement/mitkNodePredicateData.cpp
   DataManagement/mitkNodePredicateDataType.cpp
   DataManagement/mitkNodePredicateDataUID.cpp
   DataManagement/mitkNodePredicateDimension.cpp
   DataManagement/mitkNodePredicateFirstLevel.cpp
   DataManagement/mitkNodePredicateFunction.cpp
   DataManagement/mitkNodePredicateGeometry.cpp
   DataManagement/mitkNodePredicateNot.cpp
   DataManagement/mitkNodePredicateOr.cpp
   DataManagement/mitkNodePredicateProperty.cpp
   DataManagement/mitkNodePredicateDataProperty.cpp
   DataManagement/mitkNodePredicateSource.cpp
+  DataManagement/mitkNodePredicateSubGeometry.cpp
   DataManagement/mitkNumericConstants.cpp
   DataManagement/mitkPlaneGeometry.cpp
   DataManagement/mitkPlaneGeometryData.cpp
   DataManagement/mitkPlaneOperation.cpp
   DataManagement/mitkPlaneOrientationProperty.cpp
   DataManagement/mitkPointOperation.cpp
   DataManagement/mitkPointSet.cpp
   DataManagement/mitkPointSetShapeProperty.cpp
   DataManagement/mitkProperties.cpp
   DataManagement/mitkPropertyAliases.cpp
   DataManagement/mitkPropertyDescriptions.cpp
   DataManagement/mitkPropertyExtension.cpp
   DataManagement/mitkPropertyExtensions.cpp
   DataManagement/mitkPropertyFilter.cpp
   DataManagement/mitkPropertyFilters.cpp
   DataManagement/mitkPropertyKeyPath.cpp
   DataManagement/mitkPropertyList.cpp
   DataManagement/mitkPropertyListReplacedObserver.cpp
   DataManagement/mitkPropertyNameHelper.cpp
   DataManagement/mitkPropertyObserver.cpp
   DataManagement/mitkPropertyPersistence.cpp
   DataManagement/mitkPropertyPersistenceInfo.cpp
   DataManagement/mitkPropertyRelationRuleBase.cpp
   DataManagement/mitkProportionalTimeGeometry.cpp
   DataManagement/mitkRenderingModeProperty.cpp
   DataManagement/mitkResliceMethodProperty.cpp
   DataManagement/mitkRestorePlanePositionOperation.cpp
   DataManagement/mitkRotationOperation.cpp
   DataManagement/mitkScaleOperation.cpp
   DataManagement/mitkSlicedData.cpp
   DataManagement/mitkSlicedGeometry3D.cpp
   DataManagement/mitkSmartPointerProperty.cpp
   DataManagement/mitkStandaloneDataStorage.cpp
   DataManagement/mitkStringProperty.cpp
   DataManagement/mitkSurface.cpp
   DataManagement/mitkSurfaceOperation.cpp
   DataManagement/mitkSourceImageRelationRule.cpp
   DataManagement/mitkThinPlateSplineCurvedGeometry.cpp
   DataManagement/mitkTimeGeometry.cpp
   DataManagement/mitkTransferFunction.cpp
   DataManagement/mitkTransferFunctionInitializer.cpp
   DataManagement/mitkTransferFunctionProperty.cpp
   DataManagement/mitkTemporoSpatialStringProperty.cpp
   DataManagement/mitkUIDManipulator.cpp
   DataManagement/mitkVector.cpp
   DataManagement/mitkVectorProperty.cpp
   DataManagement/mitkVtkInterpolationProperty.cpp
   DataManagement/mitkVtkRepresentationProperty.cpp
   DataManagement/mitkVtkResliceInterpolationProperty.cpp
   DataManagement/mitkVtkScalarModeProperty.cpp
   DataManagement/mitkVtkVolumeRenderingProperty.cpp
   DataManagement/mitkWeakPointerProperty.cpp
   DataManagement/mitkIPropertyRelations.cpp
   DataManagement/mitkPropertyRelations.cpp
 
   Interactions/mitkAction.cpp
   Interactions/mitkBindDispatcherInteractor.cpp
   Interactions/mitkCrosshairPositionEvent.cpp
   Interactions/mitkDataInteractor.cpp
   Interactions/mitkDispatcher.cpp
   Interactions/mitkDisplayActionEventBroadcast.cpp
   Interactions/mitkDisplayActionEventFunctions.cpp
   Interactions/mitkDisplayActionEventHandler.cpp
   Interactions/mitkDisplayActionEventHandlerDesynchronized.cpp
   Interactions/mitkDisplayActionEventHandlerStd.cpp
   Interactions/mitkDisplayActionEventHandlerSynchronized.cpp
   Interactions/mitkDisplayCoordinateOperation.cpp
   Interactions/mitkDisplayInteractor.cpp
   Interactions/mitkEventConfig.cpp
   Interactions/mitkEventFactory.cpp
   Interactions/mitkEventRecorder.cpp
   Interactions/mitkEventStateMachine.cpp
   Interactions/mitkInteractionEventConst.cpp
   Interactions/mitkInteractionEvent.cpp
   Interactions/mitkInteractionEventHandler.cpp
   Interactions/mitkInteractionEventObserver.cpp
   Interactions/mitkInteractionKeyEvent.cpp
   Interactions/mitkInteractionPositionEvent.cpp
   Interactions/mitkInteractionSchemeSwitcher.cpp
   Interactions/mitkInternalEvent.cpp
   Interactions/mitkMouseDoubleClickEvent.cpp
   Interactions/mitkMouseModeSwitcher.cpp
   Interactions/mitkMouseMoveEvent.cpp
   Interactions/mitkMousePressEvent.cpp
   Interactions/mitkMouseReleaseEvent.cpp
   Interactions/mitkMouseWheelEvent.cpp
   Interactions/mitkPointSetDataInteractor.cpp
   Interactions/mitkSinglePointDataInteractor.cpp
   Interactions/mitkStateMachineAction.cpp
   Interactions/mitkStateMachineCondition.cpp
   Interactions/mitkStateMachineContainer.cpp
   Interactions/mitkStateMachineState.cpp
   Interactions/mitkStateMachineTransition.cpp
   Interactions/mitkVtkEventAdapter.cpp
   Interactions/mitkVtkInteractorStyle.cxx
   Interactions/mitkXML2EventParser.cpp
 
   IO/mitkAbstractFileIO.cpp
   IO/mitkAbstractFileReader.cpp
   IO/mitkAbstractFileWriter.cpp
   IO/mitkCustomMimeType.cpp
   IO/mitkFileReader.cpp
   IO/mitkFileReaderRegistry.cpp
   IO/mitkFileReaderSelector.cpp
   IO/mitkFileReaderWriterBase.cpp
   IO/mitkFileWriter.cpp
   IO/mitkFileWriterRegistry.cpp
   IO/mitkFileWriterSelector.cpp
   IO/mitkGeometry3DToXML.cpp
   IO/mitkIFileIO.cpp
   IO/mitkIFileReader.cpp
   IO/mitkIFileWriter.cpp
   IO/mitkGeometryDataReaderService.cpp
   IO/mitkGeometryDataWriterService.cpp
   IO/mitkImageGenerator.cpp
   IO/mitkImageVtkLegacyIO.cpp
   IO/mitkImageVtkXmlIO.cpp
   IO/mitkIMimeTypeProvider.cpp
   IO/mitkIOConstants.cpp
   IO/mitkIOMimeTypes.cpp
   IO/mitkIOUtil.cpp
   IO/mitkItkImageIO.cpp
   IO/mitkItkLoggingAdapter.cpp
   IO/mitkLegacyFileReaderService.cpp
   IO/mitkLegacyFileWriterService.cpp
   IO/mitkLocaleSwitch.cpp
   IO/mitkLog.cpp
   IO/mitkMimeType.cpp
   IO/mitkMimeTypeProvider.cpp
   IO/mitkOperation.cpp
   IO/mitkPixelType.cpp
   IO/mitkPointSetReaderService.cpp
   IO/mitkPointSetWriterService.cpp
   IO/mitkProportionalTimeGeometryToXML.cpp
   IO/mitkRawImageFileReader.cpp
   IO/mitkStandardFileLocations.cpp
   IO/mitkSurfaceStlIO.cpp
   IO/mitkSurfaceVtkIO.cpp
   IO/mitkSurfaceVtkLegacyIO.cpp
   IO/mitkSurfaceVtkXmlIO.cpp
   IO/mitkVtkLoggingAdapter.cpp
   IO/mitkPreferenceListReaderOptionsFunctor.cpp
   IO/mitkIOMetaInformationPropertyConstants.cpp
 
   Rendering/mitkAbstractAnnotationRenderer.cpp
   Rendering/mitkAnnotationUtils.cpp
   Rendering/mitkBaseRenderer.cpp
   #Rendering/mitkGLMapper.cpp Moved to deprecated LegacyGL Module
   Rendering/mitkGradientBackground.cpp
   Rendering/mitkImageVtkMapper2D.cpp
   Rendering/mitkMapper.cpp
   Rendering/mitkAnnotation.cpp
   Rendering/mitkPlaneGeometryDataMapper2D.cpp
   Rendering/mitkPlaneGeometryDataVtkMapper3D.cpp
   Rendering/mitkPointSetVtkMapper2D.cpp
   Rendering/mitkPointSetVtkMapper3D.cpp
   Rendering/mitkRenderWindowBase.cpp
   Rendering/mitkRenderWindow.cpp
   Rendering/mitkRenderWindowFrame.cpp
   #Rendering/mitkSurfaceGLMapper2D.cpp Moved to deprecated LegacyGL Module
   Rendering/mitkSurfaceVtkMapper2D.cpp
   Rendering/mitkSurfaceVtkMapper3D.cpp
   Rendering/mitkVtkEventProvider.cpp
   Rendering/mitkVtkMapper.cpp
   Rendering/mitkVtkPropRenderer.cpp
   Rendering/mitkVtkWidgetRendering.cpp
   Rendering/vtkMitkLevelWindowFilter.cpp
   Rendering/vtkMitkRectangleProp.cpp
   Rendering/vtkMitkRenderProp.cpp
   Rendering/vtkMitkThickSlicesFilter.cpp
   Rendering/vtkNeverTranslucentTexture.cpp
 )
 
 set(RESOURCE_FILES
 Interactions/globalConfig.xml
 Interactions/DisplayInteraction.xml
 Interactions/DisplayConfig.xml
 Interactions/DisplayConfigPACS.xml
 Interactions/DisplayConfigPACSPan.xml
 Interactions/DisplayConfigPACSScroll.xml
 Interactions/DisplayConfigPACSZoom.xml
 Interactions/DisplayConfigPACSLevelWindow.xml
 Interactions/DisplayConfigMITK.xml
 Interactions/DisplayConfigMITKNoCrosshair.xml
 Interactions/DisplayConfigMITKRotation.xml
 Interactions/DisplayConfigMITKRotationUnCoupled.xml
 Interactions/DisplayConfigMITKSwivel.xml
 Interactions/DisplayConfigMITKLimited.xml
 Interactions/PointSet.xml
 Interactions/Legacy/StateMachine.xml
 Interactions/Legacy/DisplayConfigMITKTools.xml
 Interactions/PointSetConfig.xml
 
 mitkLevelWindowPresets.xml
 mitkAnatomicalStructureColorPresets.xml
 )
diff --git a/Modules/Core/include/mitkBaseGeometry.h b/Modules/Core/include/mitkBaseGeometry.h
index 7854b69e06..272521a625 100644
--- a/Modules/Core/include/mitkBaseGeometry.h
+++ b/Modules/Core/include/mitkBaseGeometry.h
@@ -1,761 +1,786 @@
 /*============================================================================
 
 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 BaseGeometry_H_HEADER_INCLUDED
 #define BaseGeometry_H_HEADER_INCLUDED
 
 #include "mitkOperationActor.h"
 #include <MitkCoreExports.h>
 #include <mitkCommon.h>
 
 #include "itkScalableAffineTransform.h"
 #include "mitkNumericTypes.h"
 #include <itkAffineGeometryFrame.h>
 #include <itkBoundingBox.h>
 #include <itkIndex.h>
 #include <itkQuaternionRigidTransform.h>
 #include <mitkAffineTransform3D.h>
 
 #include <mitkGeometryTransformHolder.h>
 #include <vtkTransform.h>
 
 class vtkMatrix4x4;
 class vtkMatrixToLinearTransform;
 class vtkLinearTransform;
 
 namespace mitk
 {
   //##Documentation
   //## @brief Standard 3D-BoundingBox typedef
   //##
   //## Standard 3D-BoundingBox typedef to get rid of template arguments (3D, type).
   typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBox;
 
   //##Documentation
   //## @brief Standard typedef for time-bounds
   typedef itk::FixedArray<ScalarType, 2> TimeBounds;
   typedef itk::FixedArray<ScalarType, 3> FixedArrayType;
 
   typedef itk::AffineGeometryFrame<ScalarType, 3> AffineGeometryFrame3D;
 
   //##Documentation
   //## @brief BaseGeometry Describes the geometry of a data object
   //##
   //## The class holds
   //## \li a bounding box which is axes-parallel in intrinsic coordinates
   //## (often integer indices of pixels), to be accessed by
   //## GetBoundingBox()
   //## \li a transform to convert intrinsic coordinates into a
   //## world-coordinate system with coordinates in millimeters
   //## and milliseconds (all are floating point values), to
   //## be accessed by GetIndexToWorldTransform()
   //## \li an origin and spacing to define the geometry
   //##
   //## BaseGeometry and its sub-classes allow converting between
   //## intrinsic coordinates (called index or unit coordinates)
   //## and world-coordinates (called world or mm coordinates),
   //## e.g. WorldToIndex.
   //## In case you need integer index coordinates, provide an
   //## mitk::Index3D (or itk::Index) as target variable to
   //## WorldToIndex, otherwise you will get a continuous index
   //## (floating point values).
   //##
   //## An important sub-class is SlicedGeometry3D, which descibes
   //## data objects consisting of slices, e.g., objects of type Image.
   //## Conversions between world coordinates (in mm) and unit coordinates
   //## (e.g., pixels in the case of an Image) can be performed.
   //##
   //## For more information on related classes, see \ref Geometry.
   //##
   //## BaseGeometry instances referring to an Image need a slightly
   //## different definition of corners, see SetImageGeometry. This
   //## is usualy automatically called by Image.
   //##
   //## BaseGeometry have to be initialized in the method GenerateOutputInformation()
   //## of BaseProcess (or CopyInformation/ UpdateOutputInformation of BaseData,
   //## if possible, e.g., by analyzing pic tags in Image) subclasses. See also
   //## itk::ProcessObject::GenerateOutputInformation(),
   //## itk::DataObject::CopyInformation() and
   //## itk::DataObject::UpdateOutputInformation().
   //##
   //## At least, it can return the bounding box of the data object.
   //##
   //## The BaseGeometry class is an abstract class. The most simple implementation
   //## is the sublass Geometry3D.
   //##
   //## Rule: everything is in mm (ms) if not stated otherwise.
   //## @ingroup Geometry
   class MITKCORE_EXPORT BaseGeometry : public itk::Object, public OperationActor
   {
   public:
     mitkClassMacroItkParent(BaseGeometry, itk::Object);
     itkCloneMacro(Self);
 
       // ********************************** TypeDef **********************************
 
       typedef GeometryTransformHolder::TransformType TransformType;
     typedef itk::BoundingBox<unsigned long, 3, ScalarType> BoundingBoxType;
     typedef BoundingBoxType::BoundsArrayType BoundsArrayType;
     typedef BoundingBoxType::Pointer BoundingBoxPointer;
 
     // ********************************** Origin, Spacing **********************************
 
     //##Documentation
     //## @brief Get the origin, e.g. the upper-left corner of the plane
     const Point3D GetOrigin() const;
 
     //##Documentation
     //## @brief Set the origin, i.e. the upper-left corner of the plane
     //##
     void SetOrigin(const Point3D &origin);
 
     //##Documentation
     //## @brief Get the spacing (size of a pixel).
     //##
     const mitk::Vector3D GetSpacing() const;
 
     //##Documentation
     //## @brief Set the spacing (m_Spacing).
     //##
     //##The spacing is also changed in the IndexToWorldTransform.
     void SetSpacing(const mitk::Vector3D &aSpacing, bool enforceSetSpacing = false);
 
     //##Documentation
     //## @brief Get the origin as VnlVector
     //##
     //## \sa GetOrigin
     VnlVector GetOriginVnl() const;
 
     // ********************************** other functions **********************************
 
     //##Documentation
     //## @brief Get the DICOM FrameOfReferenceID referring to the
     //## used world coordinate system
     itkGetConstMacro(FrameOfReferenceID, unsigned int);
     //##Documentation
     //## @brief Set the DICOM FrameOfReferenceID referring to the
     //## used world coordinate system
     itkSetMacro(FrameOfReferenceID, unsigned int);
 
     itkGetConstMacro(IndexToWorldTransformLastModified, unsigned long);
 
     //##Documentation
     //## @brief Overload of function Modified() to prohibit several calls of Modified() using the ModifiedLock class.
     //##
     //## For the use of Modified(), see class ModifiedLock.
     void Modified() const override;
 
     friend class ModifiedLock;
 
     //##Documentation
     //## @brief Is this BaseGeometry in a state that is valid?
     //##
     //## This function returns always true in the BaseGeometry class. Other implementations are possible in subclasses.
     virtual bool IsValid() const;
 
     // ********************************** Initialize **********************************
 
     //##Documentation
     //## @brief Initialize the BaseGeometry
     void Initialize();
 
     void InitializeGeometry(Self *newGeometry) const;
 
     // ********************************** Transformations Set/Get **********************************
 
     //##Documentation
     //## @brief Get the transformation used to convert from index
     //## to world coordinates
     mitk::AffineTransform3D *GetIndexToWorldTransform();
 
     //##Documentation
     //## @brief Get the transformation used to convert from index
     //## to world coordinates
     const mitk::AffineTransform3D *GetIndexToWorldTransform() const;
 
     //## @brief Set the transformation used to convert from index
     //## to world coordinates. The spacing of the new transform is
     //## copied to m_spacing.
     void SetIndexToWorldTransform(mitk::AffineTransform3D *transform);
 
     //##Documentation
     //## @brief Convenience method for setting the ITK transform
     //## (m_IndexToWorldTransform) via an vtkMatrix4x4.The spacing of
     //## the new transform is copied to m_spacing.
     //## \sa SetIndexToWorldTransform
     void SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4 *vtkmatrix);
 
     //## @brief Set the transformation used to convert from index
     //## to world coordinates.This function keeps the original spacing.
     void SetIndexToWorldTransformWithoutChangingSpacing(mitk::AffineTransform3D *transform);
 
     //##Documentation
     //## @brief Convenience method for setting the ITK transform
     //## (m_IndexToWorldTransform) via an vtkMatrix4x4. This function keeps the original spacing.
     //## \sa SetIndexToWorldTransform
     void SetIndexToWorldTransformByVtkMatrixWithoutChangingSpacing(vtkMatrix4x4 *vtkmatrix);
 
     //## Get the Vtk Matrix which describes the transform.
     vtkMatrix4x4 *GetVtkMatrix();
 
     //##Documentation
     //## @brief Get the m_IndexToWorldTransform as a vtkLinearTransform
     vtkLinearTransform *GetVtkTransform() const;
 
     //##Documentation
     //## @brief Set the transform to identity, the spacing to 1 and origin to 0
     //##
     void SetIdentity();
 
     // ********************************** Transformations **********************************
 
     //##Documentation
     //## @brief Compose new IndexToWorldTransform with a given transform.
     //##
     //## This method composes m_IndexToWorldTransform with another transform,
     //## modifying self to be the composition of self and other.
     //## If the argument pre is true, then other is precomposed with self;
     //## that is, the resulting transformation consists of first applying
     //## other to the source, followed by self. If pre is false or omitted,
     //## then other is post-composed with self; that is the resulting
     //## transformation consists of first applying self to the source,
     //## followed by other.
     //## This method also changes m_spacing.
     void Compose(const TransformType *other, bool pre = false);
 
     //##Documentation
     //## @brief Compose new IndexToWorldTransform with a given vtkMatrix4x4.
     //##
     //## Converts the vtkMatrix4x4 into a itk-transform and calls the previous method.
     void Compose(const vtkMatrix4x4 *vtkmatrix, bool pre = false);
 
     //##Documentation
     //## @brief Translate the origin by a vector
     //##
     void Translate(const Vector3D &vector);
 
     //##Documentation
     //##@brief executes affine operations (translate, rotate, scale)
     void ExecuteOperation(Operation *operation) override;
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em point to (continuous!) index coordinates
     //## \warning If you need (discrete) integer index coordinates (e.g., for iterating easily over an image),
     //## use WorldToIndex(const mitk::Point3D& pt_mm, itk::Index<VIndexDimension> &index).
     //## For further information about coordinates types, please see the Geometry documentation
     void WorldToIndex(const mitk::Point3D &pt_mm, mitk::Point3D &pt_units) const;
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em vector
     //## \a vec_mm to (continuous!) index coordinates.
     //## For further information about coordinates types, please see the Geometry documentation
     void WorldToIndex(const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const;
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em point to (discrete!) index coordinates.
     //## This method rounds to integer indices!
     //## For further information about coordinates types, please see the Geometry documentation
     template <unsigned int VIndexDimension>
     void WorldToIndex(const mitk::Point3D &pt_mm, itk::Index<VIndexDimension> &index) const
     {
       typedef itk::Index<VIndexDimension> IndexType;
       mitk::Point3D pt_units;
       this->WorldToIndex(pt_mm, pt_units);
       int i, dim = index.GetIndexDimension();
       if (dim > 3)
       {
         index.Fill(0);
         dim = 3;
       }
       for (i = 0; i < dim; ++i)
       {
         index[i] = itk::Math::RoundHalfIntegerUp<typename IndexType::IndexValueType>(pt_units[i]);
       }
     }
 
     //##Documentation
     //## @brief Convert (continuous or discrete) index coordinates of a \em vector
     //## \a vec_units to world coordinates (in mm)
     //## For further information about coordinates types, please see the Geometry documentation
     void IndexToWorld(const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const;
 
     //##Documentation
     //## @brief Convert (continuous or discrete) index coordinates of a \em point to world coordinates (in mm)
     //## For further information about coordinates types, please see the Geometry documentation
     void IndexToWorld(const mitk::Point3D &pt_units, mitk::Point3D &pt_mm) const;
 
     //##Documentation
     //## @brief Convert (discrete) index coordinates of a \em point to world coordinates (in mm)
     //## For further information about coordinates types, please see the Geometry documentation
     template <unsigned int VIndexDimension>
     void IndexToWorld(const itk::Index<VIndexDimension> &index, mitk::Point3D &pt_mm) const
     {
       mitk::Point3D pt_units;
       pt_units.Fill(0);
       int i, dim = index.GetIndexDimension();
       if (dim > 3)
       {
         dim = 3;
       }
       for (i = 0; i < dim; ++i)
       {
         pt_units[i] = index[i];
       }
 
       IndexToWorld(pt_units, pt_mm);
     }
 
     //##Documentation
     //## @brief Convert (continuous or discrete) index coordinates of a \em vector
     //## \a vec_units to world coordinates (in mm)
     //## @deprecated First parameter (Point3D) is not used. If possible, please use void IndexToWorld(const
     // mitk::Vector3D& vec_units, mitk::Vector3D& vec_mm) const.
     //## For further information about coordinates types, please see the Geometry documentation
     void IndexToWorld(const mitk::Point3D &atPt3d_units, const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const;
 
     //##Documentation
     //## @brief Convert world coordinates (in mm) of a \em vector
     //## \a vec_mm to (continuous!) index coordinates.
     //## @deprecated First parameter (Point3D) is not used. If possible, please use void WorldToIndex(const
     // mitk::Vector3D& vec_mm, mitk::Vector3D& vec_units) const.
     //## For further information about coordinates types, please see the Geometry documentation
     void WorldToIndex(const mitk::Point3D &atPt3d_mm, const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const;
 
     //##Documentation
     //## @brief Deprecated for use with ITK version 3.10 or newer.
     //## Convert ITK physical coordinates of a \em point (in mm,
     //## but without a rotation) into MITK world coordinates (in mm)
     //##
     //## For more information, see WorldToItkPhysicalPoint.
     template <class TCoordRep>
     void ItkPhysicalPointToWorld(const itk::Point<TCoordRep, 3> &itkPhysicalPoint, mitk::Point3D &pt_mm) const
     {
       mitk::vtk2itk(itkPhysicalPoint, pt_mm);
     }
 
     //##Documentation
     //## @brief Deprecated for use with ITK version 3.10 or newer.
     //## Convert world coordinates (in mm) of a \em point to
     //## ITK physical coordinates (in mm, but without a possible rotation)
     //##
     //## This method is useful if you have want to access an mitk::Image
     //## via an itk::Image. ITK v3.8 and older did not support rotated (tilted)
     //## images, i.e., ITK images are always parallel to the coordinate axes.
     //## When accessing a (possibly rotated) mitk::Image via an itk::Image
     //## the rotational part of the transformation in the BaseGeometry is
     //## simply discarded; in other word: only the origin and spacing is
     //## used by ITK, not the complete matrix available in MITK.
     //## With WorldToItkPhysicalPoint you can convert an MITK world
     //## coordinate (including the rotation) into a coordinate that
     //## can be used with the ITK image as a ITK physical coordinate
     //## (excluding the rotation).
     template <class TCoordRep>
     void WorldToItkPhysicalPoint(const mitk::Point3D &pt_mm, itk::Point<TCoordRep, 3> &itkPhysicalPoint) const
     {
       mitk::vtk2itk(pt_mm, itkPhysicalPoint);
     }
 
     // ********************************** BoundingBox **********************************
 
     /** Get the bounding box */
     itkGetConstObjectMacro(BoundingBox, BoundingBoxType);
 
 // a bit of a misuse, but we want only doxygen to see the following:
 #ifdef DOXYGEN_SKIP
     //##Documentation
     //## @brief Get bounding box (in index/unit coordinates)
     itkGetConstObjectMacro(BoundingBox, BoundingBoxType);
     //##Documentation
     //## @brief Get bounding box (in index/unit coordinates) as a BoundsArrayType
     const BoundsArrayType GetBounds() const;
 #endif
     const BoundsArrayType GetBounds() const;
 
     //##Documentation
     //## \brief Set the bounding box (in index/unit coordinates)
     //##
     //## Only possible via the BoundsArray to make clear that a
     //## copy of the bounding-box is stored, not a reference to it.
     void SetBounds(const BoundsArrayType &bounds);
 
     //##Documentation
     //## @brief Set the bounding box (in index/unit coordinates) via a float array
     void SetFloatBounds(const float bounds[6]);
     //##Documentation
     //## @brief Set the bounding box (in index/unit coordinates) via a double array
     void SetFloatBounds(const double bounds[6]);
 
     //##Documentation
     //## @brief Get a VnlVector along bounding-box in the specified
     //## @a direction, length is spacing
     //##
     //## \sa GetAxisVector
     VnlVector GetMatrixColumn(unsigned int direction) const;
 
     //##Documentation
     //## @brief Calculates a bounding-box around the geometry relative
     //## to a coordinate system defined by a transform
     //##
     mitk::BoundingBox::Pointer CalculateBoundingBoxRelativeToTransform(const mitk::AffineTransform3D *transform) const;
 
 //##Documentation
 //## @brief Set the time bounds (in ms)
 // void SetTimeBounds(const TimeBounds& timebounds);
 
 // ********************************** Geometry **********************************
 
 #ifdef DOXYGEN_SKIP
     //##Documentation
     //## @brief Get the extent of the bounding box (in index/unit coordinates)
     //##
     //## To access the extent in mm use GetExtentInMM
     ScalarType GetExtent(unsigned int direction) const;
 #endif
 
     /** Get the extent of the bounding box */
     ScalarType GetExtent(unsigned int direction) const;
 
     //##Documentation
     //## @brief Get the extent of the bounding-box in the specified @a direction in mm
     //##
     //## Equals length of GetAxisVector(direction).
     ScalarType GetExtentInMM(int direction) const;
 
     //##Documentation
     //## @brief Get vector along bounding-box in the specified @a direction in mm
     //##
     //## The length of the vector is the size of the bounding-box in the
     //## specified @a direction in mm
     //## \sa GetMatrixColumn
     Vector3D GetAxisVector(unsigned int direction) const;
 
     //##Documentation
     //## @brief Checks, if the given geometry can be converted to 2D without information loss
     //## e.g. when a 2D image is saved, the matrix is usually cropped to 2x2, and when you load it back to MITK
     //## it will be filled with standard values. This function checks, if information would be lost during this
     //## procedure
     virtual bool Is2DConvertable();
 
     //##Documentation
     //## @brief Get the center of the bounding-box in mm
     //##
     Point3D GetCenter() const;
 
     //##Documentation
     //## @brief Get the squared length of the diagonal of the bounding-box in mm
     //##
     double GetDiagonalLength2() const;
 
     //##Documentation
     //## @brief Get the length of the diagonal of the bounding-box in mm
     //##
     double GetDiagonalLength() const;
 
     //##Documentation
     //## @brief Get the position of the corner number \a id (in world coordinates)
     //##
     //## See SetImageGeometry for how a corner is defined on images.
     Point3D GetCornerPoint(int id) const;
 
     //##Documentation
     //## @brief Get the position of a corner (in world coordinates)
     //##
     //## See SetImageGeometry for how a corner is defined on images.
     Point3D GetCornerPoint(bool xFront = true, bool yFront = true, bool zFront = true) const;
 
     //##Documentation
     //## @brief Set the extent of the bounding-box in the specified @a direction in mm
     //##
     //## @note This changes the matrix in the transform, @a not the bounds, which are given in units!
     void SetExtentInMM(int direction, ScalarType extentInMM);
 
     //##Documentation
     //## @brief Test whether the point \a p (world coordinates in mm) is
     //## inside the bounding box
     bool IsInside(const mitk::Point3D &p) const;
 
     //##Documentation
     //## @brief Test whether the point \a p ((continous!)index coordinates in units) is
     //## inside the bounding box
     bool IsIndexInside(const mitk::Point3D &index) const;
 
     //##Documentation
     //## @brief Convenience method for working with ITK indices
     template <unsigned int VIndexDimension>
     bool IsIndexInside(const itk::Index<VIndexDimension> &index) const
     {
       int i, dim = index.GetIndexDimension();
       Point3D pt_index;
       pt_index.Fill(0);
       for (i = 0; i < dim; ++i)
       {
         pt_index[i] = index[i];
       }
       return IsIndexInside(pt_index);
     }
 
     // ********************************* Image Geometry ********************************
     //##Documentation
     //## @brief When switching from an Image Geometry to a normal Geometry (and the other way around), you have to
     //change
     // the origin as well (See Geometry Documentation)! This function will change the "isImageGeometry" bool flag and
     // changes the origin respectively.
     virtual void ChangeImageGeometryConsideringOriginOffset(const bool isAnImageGeometry);
 
     //##Documentation
     //## @brief Is this an ImageGeometry?
     //##
     //## For more information, see SetImageGeometry
     itkGetConstMacro(ImageGeometry, bool)
       //##Documentation
       //## @brief Define that this BaseGeometry is refering to an Image
       //##
       //## A geometry referring to an Image needs a slightly different
       //## definition of the position of the corners (see GetCornerPoint).
       //## The position of a voxel is defined by the position of its center.
       //## If we would use the origin (position of the (center of) the first
       //## voxel) as a corner and display this point, it would seem to be
       //## \em not at the corner but a bit within the image. Even worse for
       //## the opposite corner of the image: here the corner would appear
       //## outside the image (by half of the voxel diameter). Thus, we have
       //## to correct for this and to be able to do that, we need to know
       //## that the BaseGeometry is referring to an Image.
       itkSetMacro(ImageGeometry, bool);
       itkBooleanMacro(ImageGeometry);
 
         const GeometryTransformHolder *GetGeometryTransformHolder() const;
 
   protected:
     // ********************************** Constructor **********************************
     BaseGeometry();
     BaseGeometry(const BaseGeometry &other);
     ~BaseGeometry() override;
 
     //##Documentation
     //## @brief clones the geometry
     //##
     //## Overwrite in all sub-classes.
     //## Normally looks like:
     //## \code
     //##  Self::Pointer newGeometry = new Self(*this);
     //##  newGeometry->UnRegister();
     //##  return newGeometry.GetPointer();
     //## \endcode
     itk::LightObject::Pointer InternalClone() const override = 0;
 
     void PrintSelf(std::ostream &os, itk::Indent indent) const override;
 
     static const std::string GetTransformAsString(TransformType *transformType);
 
     itkGetConstMacro(NDimensions, unsigned int);
 
       bool IsBoundingBoxNull() const;
 
     bool IsIndexToWorldTransformNull() const;
 
     void SetVtkMatrixDeepCopy(vtkTransform *vtktransform);
 
     void _SetSpacing(const mitk::Vector3D &aSpacing, bool enforceSetSpacing = false);
 
     //##Documentation
     //## @brief PreSetSpacing
     //##
     //## These virtual function allows a different beahiour in subclasses.
     //## Do implement them in every subclass of BaseGeometry. If not needed, use
     //## {Superclass::PreSetSpacing();};
     virtual void PreSetSpacing(const mitk::Vector3D & /*aSpacing*/){};
 
     //##Documentation
     //## @brief CheckBounds
     //##
     //## This function is called in SetBounds. Assertions can be implemented in this function (see PlaneGeometry.cpp).
     //## If you implement this function in a subclass, make sure, that all classes were your class inherits from
     //## have an implementation of CheckBounds
     //## (e.g. inheritance BaseGeometry <- A <- B. Implementation of CheckBounds in class B needs implementation in A as
     // well!)
     virtual void CheckBounds(const BoundsArrayType & /*bounds*/){};
 
     //##Documentation
     //## @brief CheckIndexToWorldTransform
     //##
     //## This function is called in SetIndexToWorldTransform. Assertions can be implemented in this function (see
     // PlaneGeometry.cpp).
     //## In Subclasses of BaseGeometry, implement own conditions or call Superclass::CheckBounds(bounds);.
     virtual void CheckIndexToWorldTransform(mitk::AffineTransform3D * /*transform*/){};
 
   private:
     GeometryTransformHolder *m_GeometryTransform;
 
     void InitializeGeometryTransformHolder(const BaseGeometry *otherGeometry);
 
     //##Documentation
     //## @brief Bounding Box, which is axes-parallel in intrinsic coordinates
     //## (often integer indices of pixels)
     BoundingBoxPointer m_BoundingBox;
 
     unsigned int m_FrameOfReferenceID;
 
     // mitk::TimeBounds m_TimeBounds;
 
     static const unsigned int m_NDimensions = 3;
 
     mutable TransformType::Pointer m_InvertedTransform;
 
     mutable unsigned long m_IndexToWorldTransformLastModified;
 
     bool m_ImageGeometry;
 
     //##Documentation
     //## @brief ModifiedLockFlag is used to prohibit the call of Modified()
     //##
     //## For the use of this Flag, see class ModifiedLock. This flag should only be set
     //## by the ModifiedLock class!
     bool m_ModifiedLockFlag;
 
     //##Documentation
     //## @brief ModifiedcalledFlag is used to collect calls of Modified().
     //##
     //## For the use of this Flag, see class ModifiedLock. This flag should only be set
     //## by the Modified() function!
     mutable bool m_ModifiedCalledFlag;
   };
 
   // ********************************** Equal Functions **********************************
   //
   // Static compare functions mainly for testing
   //
   /**
   * @brief Equal A function comparing two geometries for beeing identical.
   * @warning This method is deprecated and will not be available in the future. Use the \a bool mitk::Equal(const
   * mitk::mitk::BaseGeometry& g1, const mitk::BaseGeometry& g2) instead.
   *
   * @ingroup MITKTestingAPI
   *
   * The function compares the spacing, origin, axisvectors, extents, the matrix of the
   * IndexToWorldTransform (elementwise), the bounding (elementwise) and the ImageGeometry flag.
   *
   * The parameter eps is a tolarence value for all methods which are internally used for comparion.
   * If you want to use different tolarance values for different parts of the geometry, feel free to use
   * the other comparison methods and write your own implementation of Equal.
   * @param rightHandSide Compare this against leftHandSide.
   * @param leftHandSide Compare this against rightHandSide.
   * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparison are true. False in any other case.
   */
   DEPRECATED(MITKCORE_EXPORT bool Equal(
     const mitk::BaseGeometry *leftHandSide, const mitk::BaseGeometry *rightHandSide, ScalarType eps, bool verbose));
 
   /**
   * @brief Equal A function comparing two geometries for beeing identical.
   *
   * @ingroup MITKTestingAPI
   *
   * The function compares the spacing, origin, axisvectors, extents, the matrix of the
   * IndexToWorldTransform (elementwise), the bounding (elementwise) and the ImageGeometry flag.
   *
   * The parameter eps is a tolarence value for all methods which are internally used for comparion.
   * If you want to use different tolarance values for different parts of the geometry, feel free to use
   * the other comparison methods and write your own implementation of Equal.
   * @param rightHandSide Compare this against leftHandSide.
   * @param leftHandSide Compare this against rightHandSide.
   * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparison are true. False in any other case.
   */
   MITKCORE_EXPORT bool Equal(const mitk::BaseGeometry &leftHandSide,
                              const mitk::BaseGeometry &rightHandSide,
                              ScalarType eps,
                              bool verbose);
 
   /**
   * @brief Equal A function comparing two transforms (TransformType) for beeing identical.
   * @warning This method is deprecated and will not be available in the future. Use the \a bool mitk::Equal(const
   * mitk::mitk::BaseGeometry::TransformType& t1, const mitk::BaseGeometry::TransformType& t2) instead.
   *
   * @ingroup MITKTestingAPI
   *
   * The function compares the IndexToWorldTransform (elementwise).
   *
   * The parameter eps is a tolarence value for all methods which are internally used for comparion.
   * @param rightHandSide Compare this against leftHandSide.
   * @param leftHandSide Compare this against rightHandSide.
   * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparison are true. False in any other case.
   */
   DEPRECATED(MITKCORE_EXPORT bool Equal(const mitk::BaseGeometry::TransformType *leftHandSide,
                                         const mitk::BaseGeometry::TransformType *rightHandSide,
                                         ScalarType eps,
                                         bool verbose));
 
   /**
   * @brief Equal A function comparing two transforms (TransformType) for beeing identical.
   *
   * @ingroup MITKTestingAPI
   *
   * The function compares the IndexToWorldTransform (elementwise).
   *
   * The parameter eps is a tolarence value for all methods which are internally used for comparion.
   * @param rightHandSide Compare this against leftHandSide.
   * @param leftHandSide Compare this against rightHandSide.
   * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparison are true. False in any other case.
   */
   MITKCORE_EXPORT bool Equal(const mitk::BaseGeometry::TransformType &leftHandSide,
                              const mitk::BaseGeometry::TransformType &rightHandSide,
                              ScalarType eps,
                              bool verbose);
 
   /**
   * @brief Equal A function comparing two bounding boxes (BoundingBoxType) for beeing identical.
   * @warning This method is deprecated and will not be available in the future. Use the \a bool mitk::Equal(const
   * mitk::mitk::BaseGeometry::BoundingBoxType& b1, const mitk::BaseGeometry::BoundingBoxType& b2) instead.
   *
   * @ingroup MITKTestingAPI
   *
   * The function compares the bounds (elementwise).
   *
   * The parameter eps is a tolarence value for all methods which are internally used for comparion.
   * @param rightHandSide Compare this against leftHandSide.
   * @param leftHandSide Compare this against rightHandSide.
   * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparison are true. False in any other case.
   */
   DEPRECATED(MITKCORE_EXPORT bool Equal(const mitk::BaseGeometry::BoundingBoxType *leftHandSide,
                                         const mitk::BaseGeometry::BoundingBoxType *rightHandSide,
                                         ScalarType eps,
                                         bool verbose));
 
   /**
   * @brief Equal A function comparing two bounding boxes (BoundingBoxType) for beeing identical.
   *
   * @ingroup MITKTestingAPI
   *
   * The function compares the bounds (elementwise).
   *
   * The parameter eps is a tolarence value for all methods which are internally used for comparion.
   * @param rightHandSide Compare this against leftHandSide.
   * @param leftHandSide Compare this against rightHandSide.
   * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
   * @param verbose Flag indicating if the user wants detailed console output or not.
   * @return True, if all comparison are true. False in any other case.
   */
   MITKCORE_EXPORT bool Equal(const mitk::BaseGeometry::BoundingBoxType &leftHandSide,
                              const mitk::BaseGeometry::BoundingBoxType &rightHandSide,
                              ScalarType eps,
                              bool verbose);
+
+  /**
+  * @brief A function checks if a test geometry is a sub geometry of
+  * a given reference geometry.
+  *
+  * Sub geometry means that both geometries have the same voxel grid (same spacing, same axes,
+  * orgin is on voxel grid), but the bounding box of the checked geometry is contained or equal
+  * to the bounding box of the reference geometry.\n
+  * By this definition equal geometries are always sub geometries of each other.
+  *
+  * The function checks the spacing, origin, axis vectors, extents, the matrix of the
+  * IndexToWorldTransform (elementwise), the bounding (elementwise) and the ImageGeometry flag.
+  *
+  * The parameter eps is a tolarence value for all methods which are internally used for comparison.
+  * @param testGeo Geometry that should be checked if it is a sub geometry of referenceGeo.
+  * @param referenceGeo Geometry that should contain testedGeometry as sub geometry.
+  * @param eps Tolarence for comparison. You can use mitk::eps in most cases.
+  * @param verbose Flag indicating if the user wants detailed console output or not.
+  * @return True, if all comparison are true. False otherwise.
+  */
+  MITKCORE_EXPORT bool IsSubGeometry(const mitk::BaseGeometry& testGeo,
+    const mitk::BaseGeometry& referenceGeo,
+    ScalarType eps,
+    bool verbose);
+
 } // namespace mitk
 
 #endif /* BaseGeometry_H_HEADER_INCLUDED */
diff --git a/Modules/Core/include/mitkNodePredicateSubGeometry.h b/Modules/Core/include/mitkNodePredicateSubGeometry.h
new file mode 100644
index 0000000000..dbb6dcc602
--- /dev/null
+++ b/Modules/Core/include/mitkNodePredicateSubGeometry.h
@@ -0,0 +1,68 @@
+/*============================================================================
+
+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 MITKNODEPREDICATESUBGEOMETRY_H_HEADER_INCLUDED_
+#define MITKNODEPREDICATESUBGEOMETRY_H_HEADER_INCLUDED_
+
+#include "mitkNodePredicateBase.h"
+#include "mitkBaseGeometry.h"
+#include "mitkTimeGeometry.h"
+
+namespace mitk
+{
+  class BaseData;
+
+  /**Documentation
+   @brief Predicate that evaluates if the given DataNode's data object
+   has a geometry that is a sub geomety of the reference geometry.
+   Sub geometry means that both geometries have the same voxel grid (same spacing, same axes,
+   orgin is on voxel grid), but the bounding box of the checked geometry is contained or equal
+   to the bounding box of the reference geometry.\n
+   One can either check the whole time geometry of
+   the data node by defining a referenc time geometry or check against one given2
+   reference base geometry. If the predicate should check against a base geometry,
+   you can specify the timepoint of the data's time geometry that should be checked.
+   If no timepoint is defined the predicate will evaluate the data geometry in
+   the first timestep.
+   Evaluates to "false" for unsupported or undefined data objects/geometries.
+   @ingroup DataStorage */
+  class MITKCORE_EXPORT NodePredicateSubGeometry : public NodePredicateBase
+  {
+  public:
+    mitkClassMacro(NodePredicateSubGeometry, NodePredicateBase);
+    mitkNewMacro1Param(NodePredicateSubGeometry, const BaseGeometry*);
+    mitkNewMacro2Param(NodePredicateSubGeometry, const BaseGeometry*, TimePointType);
+
+    itkSetMacro(CheckPrecision, mitk::ScalarType);
+    itkGetMacro(CheckPrecision, mitk::ScalarType);
+
+    ~NodePredicateSubGeometry() override;
+
+    bool CheckNode(const mitk::DataNode *node) const override;
+
+  protected:
+
+    /**Constructor that is used configures the predicate to check the reference geometry against the first data timepoint.*/
+    NodePredicateSubGeometry(const BaseGeometry* refGeometry);
+    /**Constructor allows to define the timepoint that should be evaluated against the reference.*/
+    NodePredicateSubGeometry(const BaseGeometry* refGeometry, TimePointType relevantTimePoint);
+
+    BaseGeometry::ConstPointer m_RefGeometry;
+    TimePointType m_TimePoint;
+    /**Indicates if m_TimePoint should be regarded or always the first timestep should be used.*/
+    bool m_UseTimePoint;
+    /**Precision that should be used for the equal checks.*/
+    mitk::ScalarType m_CheckPrecision;
+  };
+} // namespace mitk
+
+#endif
diff --git a/Modules/Core/src/DataManagement/mitkBaseGeometry.cpp b/Modules/Core/src/DataManagement/mitkBaseGeometry.cpp
index d5bfa354e6..c2547de34b 100644
--- a/Modules/Core/src/DataManagement/mitkBaseGeometry.cpp
+++ b/Modules/Core/src/DataManagement/mitkBaseGeometry.cpp
@@ -1,1003 +1,1105 @@
 /*============================================================================
 
 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 <iomanip>
 #include <sstream>
+#include <bitset>
 
 #include <vtkMatrix4x4.h>
 #include <vtkMatrixToLinearTransform.h>
 
 #include "mitkApplyTransformMatrixOperation.h"
 #include "mitkBaseGeometry.h"
 #include "mitkGeometryTransformHolder.h"
 #include "mitkInteractionConst.h"
 #include "mitkMatrixConvert.h"
 #include "mitkModifiedLock.h"
 #include "mitkPointOperation.h"
 #include "mitkRestorePlanePositionOperation.h"
 #include "mitkRotationOperation.h"
 #include "mitkScaleOperation.h"
 #include "mitkVector.h"
+#include "mitkMatrix.h"
 
 mitk::BaseGeometry::BaseGeometry()
   : Superclass(),
     mitk::OperationActor(),
     m_FrameOfReferenceID(0),
     m_IndexToWorldTransformLastModified(0),
     m_ImageGeometry(false),
     m_ModifiedLockFlag(false),
     m_ModifiedCalledFlag(false)
 {
   m_GeometryTransform = new GeometryTransformHolder();
   Initialize();
 }
 
 mitk::BaseGeometry::BaseGeometry(const BaseGeometry &other)
   : Superclass(),
     mitk::OperationActor(),
     m_FrameOfReferenceID(other.m_FrameOfReferenceID),
     m_IndexToWorldTransformLastModified(other.m_IndexToWorldTransformLastModified),
     m_ImageGeometry(other.m_ImageGeometry),
     m_ModifiedLockFlag(false),
     m_ModifiedCalledFlag(false)
 {
   m_GeometryTransform = new GeometryTransformHolder(*other.GetGeometryTransformHolder());
   other.InitializeGeometry(this);
 }
 
 mitk::BaseGeometry::~BaseGeometry()
 {
   delete m_GeometryTransform;
 }
 
 void mitk::BaseGeometry::SetVtkMatrixDeepCopy(vtkTransform *vtktransform)
 {
   m_GeometryTransform->SetVtkMatrixDeepCopy(vtktransform);
 }
 
 const mitk::Point3D mitk::BaseGeometry::GetOrigin() const
 {
   return m_GeometryTransform->GetOrigin();
 }
 
 void mitk::BaseGeometry::SetOrigin(const Point3D &origin)
 {
   mitk::ModifiedLock lock(this);
 
   if (origin != GetOrigin())
   {
     m_GeometryTransform->SetOrigin(origin);
     Modified();
   }
 }
 
 const mitk::Vector3D mitk::BaseGeometry::GetSpacing() const
 {
   return m_GeometryTransform->GetSpacing();
 }
 
 void mitk::BaseGeometry::Initialize()
 {
   float b[6] = {0, 1, 0, 1, 0, 1};
   SetFloatBounds(b);
 
   m_GeometryTransform->Initialize();
 
   m_FrameOfReferenceID = 0;
 
   m_ImageGeometry = false;
 }
 
 void mitk::BaseGeometry::SetFloatBounds(const float bounds[6])
 {
   mitk::BoundingBox::BoundsArrayType b;
   const float *input = bounds;
   int i = 0;
   for (mitk::BoundingBox::BoundsArrayType::Iterator it = b.Begin(); i < 6; ++i)
     *it++ = (mitk::ScalarType)*input++;
   SetBounds(b);
 }
 
 void mitk::BaseGeometry::SetFloatBounds(const double bounds[6])
 {
   mitk::BoundingBox::BoundsArrayType b;
   const double *input = bounds;
   int i = 0;
   for (mitk::BoundingBox::BoundsArrayType::Iterator it = b.Begin(); i < 6; ++i)
     *it++ = (mitk::ScalarType)*input++;
   SetBounds(b);
 }
 
 /** Initialize the geometry */
 void mitk::BaseGeometry::InitializeGeometry(BaseGeometry *newGeometry) const
 {
   newGeometry->SetBounds(m_BoundingBox->GetBounds());
 
   newGeometry->SetFrameOfReferenceID(GetFrameOfReferenceID());
 
   newGeometry->InitializeGeometryTransformHolder(this);
 
   newGeometry->m_ImageGeometry = m_ImageGeometry;
 }
 
 void mitk::BaseGeometry::InitializeGeometryTransformHolder(const BaseGeometry *otherGeometry)
 {
   this->m_GeometryTransform->Initialize(otherGeometry->GetGeometryTransformHolder());
 }
 
 /** Set the bounds */
 void mitk::BaseGeometry::SetBounds(const BoundsArrayType &bounds)
 {
   mitk::ModifiedLock lock(this);
 
   this->CheckBounds(bounds);
 
   m_BoundingBox = BoundingBoxType::New();
 
   BoundingBoxType::PointsContainer::Pointer pointscontainer = BoundingBoxType::PointsContainer::New();
   BoundingBoxType::PointType p;
   BoundingBoxType::PointIdentifier pointid;
 
   for (pointid = 0; pointid < 2; ++pointid)
   {
     unsigned int i;
     for (i = 0; i < m_NDimensions; ++i)
     {
       p[i] = bounds[2 * i + pointid];
     }
     pointscontainer->InsertElement(pointid, p);
   }
 
   m_BoundingBox->SetPoints(pointscontainer);
   m_BoundingBox->ComputeBoundingBox();
   this->Modified();
 }
 
 void mitk::BaseGeometry::SetIndexToWorldTransform(mitk::AffineTransform3D *transform)
 {
   mitk::ModifiedLock lock(this);
 
   CheckIndexToWorldTransform(transform);
 
   m_GeometryTransform->SetIndexToWorldTransform(transform);
   Modified();
 }
 
 void mitk::BaseGeometry::SetIndexToWorldTransformWithoutChangingSpacing(mitk::AffineTransform3D *transform)
 {
   // security check
   mitk::Vector3D originalSpacing = this->GetSpacing();
 
   mitk::ModifiedLock lock(this);
 
   CheckIndexToWorldTransform(transform);
 
   m_GeometryTransform->SetIndexToWorldTransformWithoutChangingSpacing(transform);
   Modified();
 
   // Security check. Spacig must not have changed
   if (!mitk::Equal(originalSpacing, this->GetSpacing()))
   {
     MITK_WARN << "Spacing has changed in a method, where the spacing must not change.";
     assert(false);
   }
 }
 
 const mitk::BaseGeometry::BoundsArrayType mitk::BaseGeometry::GetBounds() const
 {
   assert(m_BoundingBox.IsNotNull());
   return m_BoundingBox->GetBounds();
 }
 
 bool mitk::BaseGeometry::IsValid() const
 {
   return true;
 }
 
 void mitk::BaseGeometry::SetSpacing(const mitk::Vector3D &aSpacing, bool enforceSetSpacing)
 {
   PreSetSpacing(aSpacing);
   _SetSpacing(aSpacing, enforceSetSpacing);
 }
 
 void mitk::BaseGeometry::_SetSpacing(const mitk::Vector3D &aSpacing, bool enforceSetSpacing)
 {
   m_GeometryTransform->SetSpacing(aSpacing, enforceSetSpacing);
 }
 
 mitk::Vector3D mitk::BaseGeometry::GetAxisVector(unsigned int direction) const
 {
   Vector3D frontToBack;
   frontToBack.SetVnlVector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(direction));
   frontToBack *= GetExtent(direction);
   return frontToBack;
 }
 
 mitk::ScalarType mitk::BaseGeometry::GetExtent(unsigned int direction) const
 {
   assert(m_BoundingBox.IsNotNull());
   if (direction >= m_NDimensions)
     mitkThrow() << "Direction is too big. This geometry is for 3D Data";
   BoundsArrayType bounds = m_BoundingBox->GetBounds();
   return bounds[direction * 2 + 1] - bounds[direction * 2];
 }
 
 bool mitk::BaseGeometry::Is2DConvertable()
 {
   bool isConvertableWithoutLoss = true;
   do
   {
     if (this->GetSpacing()[2] != 1)
     {
       isConvertableWithoutLoss = false;
       break;
     }
     if (this->GetOrigin()[2] != 0)
     {
       isConvertableWithoutLoss = false;
       break;
     }
     mitk::Vector3D col0, col1, col2;
     col0.SetVnlVector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0));
     col1.SetVnlVector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1));
     col2.SetVnlVector(this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2));
 
     if ((col0[2] != 0) || (col1[2] != 0) || (col2[0] != 0) || (col2[1] != 0) || (col2[2] != 1))
     {
       isConvertableWithoutLoss = false;
       break;
     }
   } while (false);
 
   return isConvertableWithoutLoss;
 }
 
 mitk::Point3D mitk::BaseGeometry::GetCenter() const
 {
   assert(m_BoundingBox.IsNotNull());
   Point3D c = m_BoundingBox->GetCenter();
   if (m_ImageGeometry)
   {
     // Get Center returns the middel of min and max pixel index. In corner based images, this is the right position.
     // In center based images (imageGeometry == true), the index needs to be shifted back.
     c[0] -= 0.5;
     c[1] -= 0.5;
     c[2] -= 0.5;
   }
   this->IndexToWorld(c, c);
   return c;
 }
 
 double mitk::BaseGeometry::GetDiagonalLength2() const
 {
   Vector3D diagonalvector = GetCornerPoint() - GetCornerPoint(false, false, false);
   return diagonalvector.GetSquaredNorm();
 }
 
 double mitk::BaseGeometry::GetDiagonalLength() const
 {
   return sqrt(GetDiagonalLength2());
 }
 
 mitk::Point3D mitk::BaseGeometry::GetCornerPoint(int id) const
 {
   assert(id >= 0);
   assert(this->IsBoundingBoxNull() == false);
 
   BoundingBox::BoundsArrayType bounds = this->GetBoundingBox()->GetBounds();
 
   Point3D cornerpoint;
   switch (id)
   {
     case 0:
       FillVector3D(cornerpoint, bounds[0], bounds[2], bounds[4]);
       break;
     case 1:
       FillVector3D(cornerpoint, bounds[0], bounds[2], bounds[5]);
       break;
     case 2:
       FillVector3D(cornerpoint, bounds[0], bounds[3], bounds[4]);
       break;
     case 3:
       FillVector3D(cornerpoint, bounds[0], bounds[3], bounds[5]);
       break;
     case 4:
       FillVector3D(cornerpoint, bounds[1], bounds[2], bounds[4]);
       break;
     case 5:
       FillVector3D(cornerpoint, bounds[1], bounds[2], bounds[5]);
       break;
     case 6:
       FillVector3D(cornerpoint, bounds[1], bounds[3], bounds[4]);
       break;
     case 7:
       FillVector3D(cornerpoint, bounds[1], bounds[3], bounds[5]);
       break;
     default:
     {
       itkExceptionMacro(<< "A cube only has 8 corners. These are labeled 0-7.");
     }
   }
   if (m_ImageGeometry)
   {
     // Here i have to adjust the 0.5 offset manually, because the cornerpoint is the corner of the
     // bounding box. The bounding box itself is no image, so it is corner-based
     FillVector3D(cornerpoint, cornerpoint[0] - 0.5, cornerpoint[1] - 0.5, cornerpoint[2] - 0.5);
   }
   return this->GetIndexToWorldTransform()->TransformPoint(cornerpoint);
 }
 
 mitk::Point3D mitk::BaseGeometry::GetCornerPoint(bool xFront, bool yFront, bool zFront) const
 {
   assert(this->IsBoundingBoxNull() == false);
   BoundingBox::BoundsArrayType bounds = this->GetBoundingBox()->GetBounds();
 
   Point3D cornerpoint;
   cornerpoint[0] = (xFront ? bounds[0] : bounds[1]);
   cornerpoint[1] = (yFront ? bounds[2] : bounds[3]);
   cornerpoint[2] = (zFront ? bounds[4] : bounds[5]);
   if (m_ImageGeometry)
   {
     // Here i have to adjust the 0.5 offset manually, because the cornerpoint is the corner of the
     // bounding box. The bounding box itself is no image, so it is corner-based
     FillVector3D(cornerpoint, cornerpoint[0] - 0.5, cornerpoint[1] - 0.5, cornerpoint[2] - 0.5);
   }
 
   return this->GetIndexToWorldTransform()->TransformPoint(cornerpoint);
 }
 
 mitk::ScalarType mitk::BaseGeometry::GetExtentInMM(int direction) const
 {
   return this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(direction).magnitude() *
          GetExtent(direction);
 }
 
 void mitk::BaseGeometry::SetExtentInMM(int direction, ScalarType extentInMM)
 {
   mitk::ModifiedLock lock(this);
 
   ScalarType len = GetExtentInMM(direction);
   if (fabs(len - extentInMM) >= mitk::eps)
   {
     AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
     vnlmatrix = m_GeometryTransform->GetVnlMatrix();
     if (len > extentInMM)
       vnlmatrix.set_column(direction, vnlmatrix.get_column(direction) / len * extentInMM);
     else
       vnlmatrix.set_column(direction, vnlmatrix.get_column(direction) * extentInMM / len);
     Matrix3D matrix;
     matrix = vnlmatrix;
     m_GeometryTransform->SetMatrix(matrix);
 
     Modified();
   }
 }
 
 bool mitk::BaseGeometry::IsInside(const mitk::Point3D &p) const
 {
   mitk::Point3D index;
   WorldToIndex(p, index);
   return IsIndexInside(index);
 }
 
 bool mitk::BaseGeometry::IsIndexInside(const mitk::Point3D &index) const
 {
   bool inside = false;
   // if it is an image geometry, we need to convert the index to discrete values
   // this is done by applying the rounding function also used in WorldToIndex (see line 323)
   if (m_ImageGeometry)
   {
     mitk::Point3D discretIndex;
     discretIndex[0] = itk::Math::RoundHalfIntegerUp<mitk::ScalarType>(index[0]);
     discretIndex[1] = itk::Math::RoundHalfIntegerUp<mitk::ScalarType>(index[1]);
     discretIndex[2] = itk::Math::RoundHalfIntegerUp<mitk::ScalarType>(index[2]);
 
     inside = this->GetBoundingBox()->IsInside(discretIndex);
     // we have to check if the index is at the upper border of each dimension,
     // because the boundingbox is not centerbased
     if (inside)
     {
       const BoundingBox::BoundsArrayType &bounds = this->GetBoundingBox()->GetBounds();
       if ((discretIndex[0] == bounds[1]) || (discretIndex[1] == bounds[3]) || (discretIndex[2] == bounds[5]))
         inside = false;
     }
   }
   else
     inside = this->GetBoundingBox()->IsInside(index);
 
   return inside;
 }
 
 void mitk::BaseGeometry::WorldToIndex(const mitk::Point3D &pt_mm, mitk::Point3D &pt_units) const
 {
   mitk::Vector3D tempIn, tempOut;
   const TransformType::OffsetType &offset = this->GetIndexToWorldTransform()->GetOffset();
   tempIn = pt_mm.GetVectorFromOrigin() - offset;
 
   WorldToIndex(tempIn, tempOut);
 
   pt_units = tempOut;
 }
 
 void mitk::BaseGeometry::WorldToIndex(const mitk::Vector3D &vec_mm, mitk::Vector3D &vec_units) const
 {
   // Get WorldToIndex transform
   if (m_IndexToWorldTransformLastModified != this->GetIndexToWorldTransform()->GetMTime())
   {
     if (!m_InvertedTransform)
     {
       m_InvertedTransform = TransformType::New();
     }
     if (!this->GetIndexToWorldTransform()->GetInverse(m_InvertedTransform.GetPointer()))
     {
       itkExceptionMacro("Internal ITK matrix inversion error, cannot proceed.");
     }
     m_IndexToWorldTransformLastModified = this->GetIndexToWorldTransform()->GetMTime();
   }
 
   // Check for valid matrix inversion
   const TransformType::MatrixType &inverse = m_InvertedTransform->GetMatrix();
   if (inverse.GetVnlMatrix().has_nans())
   {
     itkExceptionMacro("Internal ITK matrix inversion error, cannot proceed. Matrix was: "
                       << std::endl
                       << this->GetIndexToWorldTransform()->GetMatrix()
                       << "Suggested inverted matrix is:"
                       << std::endl
                       << inverse);
   }
 
   vec_units = inverse * vec_mm;
 }
 
 void mitk::BaseGeometry::WorldToIndex(const mitk::Point3D & /*atPt3d_mm*/,
                                       const mitk::Vector3D &vec_mm,
                                       mitk::Vector3D &vec_units) const
 {
   MITK_WARN << "Warning! Call of the deprecated function BaseGeometry::WorldToIndex(point, vec, vec). Use "
                "BaseGeometry::WorldToIndex(vec, vec) instead!";
   this->WorldToIndex(vec_mm, vec_units);
 }
 
 mitk::VnlVector mitk::BaseGeometry::GetOriginVnl() const
 {
   return GetOrigin().GetVnlVector();
 }
 
 vtkLinearTransform *mitk::BaseGeometry::GetVtkTransform() const
 {
   return m_GeometryTransform->GetVtkTransform();
 }
 
 void mitk::BaseGeometry::SetIdentity()
 {
   mitk::ModifiedLock lock(this);
 
   m_GeometryTransform->SetIdentity();
   Modified();
 }
 
 void mitk::BaseGeometry::Compose(const mitk::BaseGeometry::TransformType *other, bool pre)
 {
   mitk::ModifiedLock lock(this);
   m_GeometryTransform->Compose(other, pre);
   Modified();
 }
 
 void mitk::BaseGeometry::Compose(const vtkMatrix4x4 *vtkmatrix, bool pre)
 {
   mitk::BaseGeometry::TransformType::Pointer itkTransform = mitk::BaseGeometry::TransformType::New();
   TransferVtkMatrixToItkTransform(vtkmatrix, itkTransform.GetPointer());
   Compose(itkTransform, pre);
 }
 
 void mitk::BaseGeometry::Translate(const Vector3D &vector)
 {
   if ((vector[0] != 0) || (vector[1] != 0) || (vector[2] != 0))
   {
     this->SetOrigin(this->GetOrigin() + vector);
   }
 }
 
 void mitk::BaseGeometry::IndexToWorld(const mitk::Point3D &pt_units, mitk::Point3D &pt_mm) const
 {
   pt_mm = this->GetIndexToWorldTransform()->TransformPoint(pt_units);
 }
 
 void mitk::BaseGeometry::IndexToWorld(const mitk::Vector3D &vec_units, mitk::Vector3D &vec_mm) const
 {
   vec_mm = this->GetIndexToWorldTransform()->TransformVector(vec_units);
 }
 
 void mitk::BaseGeometry::ExecuteOperation(Operation *operation)
 {
   mitk::ModifiedLock lock(this);
 
   vtkTransform *vtktransform = vtkTransform::New();
   vtktransform->SetMatrix(this->GetVtkMatrix());
   switch (operation->GetOperationType())
   {
     case OpNOTHING:
       break;
     case OpMOVE:
     {
       auto *pointOp = dynamic_cast<mitk::PointOperation *>(operation);
       if (pointOp == nullptr)
       {
         MITK_ERROR << "Point move operation is null!";
         return;
       }
       mitk::Point3D newPos = pointOp->GetPoint();
       ScalarType data[3];
       vtktransform->GetPosition(data);
       vtktransform->PostMultiply();
       vtktransform->Translate(newPos[0], newPos[1], newPos[2]);
       vtktransform->PreMultiply();
       break;
     }
     case OpSCALE:
     {
       auto *scaleOp = dynamic_cast<mitk::ScaleOperation *>(operation);
       if (scaleOp == nullptr)
       {
         MITK_ERROR << "Scale operation is null!";
         return;
       }
       mitk::Point3D newScale = scaleOp->GetScaleFactor();
       ScalarType scalefactor[3];
 
       scalefactor[0] = 1 + (newScale[0] / GetMatrixColumn(0).magnitude());
       scalefactor[1] = 1 + (newScale[1] / GetMatrixColumn(1).magnitude());
       scalefactor[2] = 1 + (newScale[2] / GetMatrixColumn(2).magnitude());
 
       mitk::Point3D anchor = scaleOp->GetScaleAnchorPoint();
 
       vtktransform->PostMultiply();
       vtktransform->Translate(-anchor[0], -anchor[1], -anchor[2]);
       vtktransform->Scale(scalefactor[0], scalefactor[1], scalefactor[2]);
       vtktransform->Translate(anchor[0], anchor[1], anchor[2]);
       break;
     }
     case OpROTATE:
     {
       auto *rotateOp = dynamic_cast<mitk::RotationOperation *>(operation);
       if (rotateOp == nullptr)
       {
         MITK_ERROR << "Rotation operation is null!";
         return;
       }
       Vector3D rotationVector = rotateOp->GetVectorOfRotation();
       Point3D center = rotateOp->GetCenterOfRotation();
       ScalarType angle = rotateOp->GetAngleOfRotation();
       vtktransform->PostMultiply();
       vtktransform->Translate(-center[0], -center[1], -center[2]);
       vtktransform->RotateWXYZ(angle, rotationVector[0], rotationVector[1], rotationVector[2]);
       vtktransform->Translate(center[0], center[1], center[2]);
       vtktransform->PreMultiply();
       break;
     }
     case OpRESTOREPLANEPOSITION:
     {
       // Copy necessary to avoid vtk warning
       vtkMatrix4x4 *matrix = vtkMatrix4x4::New();
       TransferItkTransformToVtkMatrix(
         dynamic_cast<mitk::RestorePlanePositionOperation *>(operation)->GetTransform().GetPointer(), matrix);
       vtktransform->SetMatrix(matrix);
       matrix->Delete();
       break;
     }
     case OpAPPLYTRANSFORMMATRIX:
     {
       auto *applyMatrixOp = dynamic_cast<ApplyTransformMatrixOperation *>(operation);
       vtktransform->SetMatrix(applyMatrixOp->GetMatrix());
       break;
     }
     default:
       vtktransform->Delete();
       return;
   }
   this->SetVtkMatrixDeepCopy(vtktransform);
   Modified();
   vtktransform->Delete();
 }
 
 mitk::VnlVector mitk::BaseGeometry::GetMatrixColumn(unsigned int direction) const
 {
   return this->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(direction);
 }
 
 mitk::BoundingBox::Pointer mitk::BaseGeometry::CalculateBoundingBoxRelativeToTransform(
   const mitk::AffineTransform3D *transform) const
 {
   mitk::BoundingBox::PointsContainer::Pointer pointscontainer = mitk::BoundingBox::PointsContainer::New();
 
   mitk::BoundingBox::PointIdentifier pointid = 0;
 
   unsigned char i;
   if (transform != nullptr)
   {
     mitk::AffineTransform3D::Pointer inverse = mitk::AffineTransform3D::New();
     transform->GetInverse(inverse);
     for (i = 0; i < 8; ++i)
       pointscontainer->InsertElement(pointid++, inverse->TransformPoint(GetCornerPoint(i)));
   }
   else
   {
     for (i = 0; i < 8; ++i)
       pointscontainer->InsertElement(pointid++, GetCornerPoint(i));
   }
 
   mitk::BoundingBox::Pointer result = mitk::BoundingBox::New();
   result->SetPoints(pointscontainer);
   result->ComputeBoundingBox();
 
   return result;
 }
 
 const std::string mitk::BaseGeometry::GetTransformAsString(TransformType *transformType)
 {
   std::ostringstream out;
 
   out << '[';
 
   for (int i = 0; i < 3; ++i)
   {
     out << '[';
     for (int j = 0; j < 3; ++j)
       out << transformType->GetMatrix().GetVnlMatrix().get(i, j) << ' ';
     out << ']';
   }
 
   out << "][";
 
   for (int i = 0; i < 3; ++i)
     out << transformType->GetOffset()[i] << ' ';
 
   out << "]\0";
 
   return out.str();
 }
 
 void mitk::BaseGeometry::SetIndexToWorldTransformByVtkMatrix(vtkMatrix4x4 *vtkmatrix)
 {
   m_GeometryTransform->SetIndexToWorldTransformByVtkMatrix(vtkmatrix);
 }
 
 void mitk::BaseGeometry::SetIndexToWorldTransformByVtkMatrixWithoutChangingSpacing(vtkMatrix4x4 *vtkmatrix)
 {
   m_GeometryTransform->SetIndexToWorldTransformByVtkMatrixWithoutChangingSpacing(vtkmatrix);
 }
 
 void mitk::BaseGeometry::IndexToWorld(const mitk::Point3D & /*atPt3d_units*/,
                                       const mitk::Vector3D &vec_units,
                                       mitk::Vector3D &vec_mm) const
 {
   MITK_WARN << "Warning! Call of the deprecated function BaseGeometry::IndexToWorld(point, vec, vec). Use "
                "BaseGeometry::IndexToWorld(vec, vec) instead!";
   // vec_mm = m_IndexToWorldTransform->TransformVector(vec_units);
   this->IndexToWorld(vec_units, vec_mm);
 }
 
 vtkMatrix4x4 *mitk::BaseGeometry::GetVtkMatrix()
 {
   return m_GeometryTransform->GetVtkMatrix();
 }
 
 bool mitk::BaseGeometry::IsBoundingBoxNull() const
 {
   return m_BoundingBox.IsNull();
 }
 
 bool mitk::BaseGeometry::IsIndexToWorldTransformNull() const
 {
   return m_GeometryTransform->IsIndexToWorldTransformNull();
 }
 
 void mitk::BaseGeometry::ChangeImageGeometryConsideringOriginOffset(const bool isAnImageGeometry)
 {
   // If Geometry is switched to ImageGeometry, you have to put an offset to the origin, because
   // imageGeometries origins are pixel-center-based
   // ... and remove the offset, if you switch an imageGeometry back to a normal geometry
   // For more information please see the Geometry documentation page
 
   if (m_ImageGeometry == isAnImageGeometry)
     return;
 
   const BoundingBox::BoundsArrayType &boundsarray = this->GetBoundingBox()->GetBounds();
 
   Point3D originIndex;
   FillVector3D(originIndex, boundsarray[0], boundsarray[2], boundsarray[4]);
 
   if (isAnImageGeometry == true)
     FillVector3D(originIndex, originIndex[0] + 0.5, originIndex[1] + 0.5, originIndex[2] + 0.5);
   else
     FillVector3D(originIndex, originIndex[0] - 0.5, originIndex[1] - 0.5, originIndex[2] - 0.5);
 
   Point3D originWorld;
 
   originWorld = GetIndexToWorldTransform()->TransformPoint(originIndex);
   // instead could as well call  IndexToWorld(originIndex,originWorld);
 
   SetOrigin(originWorld);
 
   this->SetImageGeometry(isAnImageGeometry);
 }
 
 void mitk::BaseGeometry::PrintSelf(std::ostream &os, itk::Indent indent) const
 {
   os << indent << " IndexToWorldTransform: ";
   if (this->IsIndexToWorldTransformNull())
     os << "nullptr" << std::endl;
   else
   {
     // from itk::MatrixOffsetTransformBase
     unsigned int i, j;
     os << std::endl;
     os << indent << "Matrix: " << std::endl;
     for (i = 0; i < 3; i++)
     {
       os << indent.GetNextIndent();
       for (j = 0; j < 3; j++)
       {
         os << this->GetIndexToWorldTransform()->GetMatrix()[i][j] << " ";
       }
       os << std::endl;
     }
 
     os << indent << "Offset: " << this->GetIndexToWorldTransform()->GetOffset() << std::endl;
     os << indent << "Center: " << this->GetIndexToWorldTransform()->GetCenter() << std::endl;
     os << indent << "Translation: " << this->GetIndexToWorldTransform()->GetTranslation() << std::endl;
 
     os << indent << "Inverse: " << std::endl;
     for (i = 0; i < 3; i++)
     {
       os << indent.GetNextIndent();
       for (j = 0; j < 3; j++)
       {
         os << this->GetIndexToWorldTransform()->GetInverseMatrix()[i][j] << " ";
       }
       os << std::endl;
     }
 
     // from itk::ScalableAffineTransform
     os << indent << "Scale : ";
     for (i = 0; i < 3; i++)
     {
       os << this->GetIndexToWorldTransform()->GetScale()[i] << " ";
     }
     os << std::endl;
   }
 
   os << indent << " BoundingBox: ";
   if (this->IsBoundingBoxNull())
     os << "nullptr" << std::endl;
   else
   {
     os << indent << "( ";
     for (unsigned int i = 0; i < 3; i++)
     {
       os << this->GetBoundingBox()->GetBounds()[2 * i] << "," << this->GetBoundingBox()->GetBounds()[2 * i + 1] << " ";
     }
     os << " )" << std::endl;
   }
 
   os << indent << " Origin: " << this->GetOrigin() << std::endl;
   os << indent << " ImageGeometry: " << this->GetImageGeometry() << std::endl;
   os << indent << " Spacing: " << this->GetSpacing() << std::endl;
 }
 
 void mitk::BaseGeometry::Modified() const
 {
   if (!m_ModifiedLockFlag)
     Superclass::Modified();
   else
     m_ModifiedCalledFlag = true;
 }
 
 mitk::AffineTransform3D *mitk::BaseGeometry::GetIndexToWorldTransform()
 {
   return m_GeometryTransform->GetIndexToWorldTransform();
 }
 
 const mitk::AffineTransform3D *mitk::BaseGeometry::GetIndexToWorldTransform() const
 {
   return m_GeometryTransform->GetIndexToWorldTransform();
 }
 
 const mitk::GeometryTransformHolder *mitk::BaseGeometry::GetGeometryTransformHolder() const
 {
   return m_GeometryTransform;
 }
 
 bool mitk::Equal(const mitk::BaseGeometry::BoundingBoxType *leftHandSide,
                  const mitk::BaseGeometry::BoundingBoxType *rightHandSide,
                  ScalarType eps,
                  bool verbose)
 {
   if ((leftHandSide == nullptr) || (rightHandSide == nullptr))
   {
     MITK_ERROR << "mitk::Equal( const mitk::Geometry3D::BoundingBoxType *leftHandSide, const "
                   "mitk::Geometry3D::BoundingBoxType *rightHandSide, ScalarType eps, bool verbose ) does not with nullptr "
                   "pointer input.";
     return false;
   }
   return Equal(*leftHandSide, *rightHandSide, eps, verbose);
 }
 
 bool mitk::Equal(const mitk::BaseGeometry::BoundingBoxType &leftHandSide,
                  const mitk::BaseGeometry::BoundingBoxType &rightHandSide,
                  ScalarType eps,
                  bool verbose)
 {
   bool result = true;
 
   BaseGeometry::BoundsArrayType rightBounds = rightHandSide.GetBounds();
   BaseGeometry::BoundsArrayType leftBounds = leftHandSide.GetBounds();
   BaseGeometry::BoundsArrayType::Iterator itLeft = leftBounds.Begin();
   for (BaseGeometry::BoundsArrayType::Iterator itRight = rightBounds.Begin(); itRight != rightBounds.End(); ++itRight)
   {
     if ((!mitk::Equal(*itLeft, *itRight, eps)))
     {
       if (verbose)
       {
         MITK_INFO << "[( Geometry3D::BoundingBoxType )] bounds are not equal.";
         MITK_INFO << "rightHandSide is " << setprecision(12) << *itRight << " : leftHandSide is " << *itLeft
                   << " and tolerance is " << eps;
       }
       result = false;
     }
     itLeft++;
   }
   return result;
 }
 
 bool mitk::Equal(const mitk::BaseGeometry *leftHandSide,
                  const mitk::BaseGeometry *rightHandSide,
                  ScalarType eps,
                  bool verbose)
 {
   if ((leftHandSide == nullptr) || (rightHandSide == nullptr))
   {
     MITK_ERROR << "mitk::Equal(const mitk::Geometry3D *leftHandSide, const mitk::Geometry3D *rightHandSide, ScalarType "
                   "eps, bool verbose) does not with nullptr pointer input.";
     return false;
   }
   return Equal(*leftHandSide, *rightHandSide, eps, verbose);
 }
 
 bool mitk::Equal(const mitk::BaseGeometry &leftHandSide,
                  const mitk::BaseGeometry &rightHandSide,
                  ScalarType eps,
                  bool verbose)
 {
   bool result = true;
 
   // Compare spacings
   if (!mitk::Equal(leftHandSide.GetSpacing(), rightHandSide.GetSpacing(), eps))
   {
     if (verbose)
     {
       MITK_INFO << "[( Geometry3D )] Spacing differs.";
       MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetSpacing() << " : leftHandSide is "
                 << leftHandSide.GetSpacing() << " and tolerance is " << eps;
     }
     result = false;
   }
 
   // Compare Origins
   if (!mitk::Equal(leftHandSide.GetOrigin(), rightHandSide.GetOrigin(), eps))
   {
     if (verbose)
     {
       MITK_INFO << "[( Geometry3D )] Origin differs.";
       MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetOrigin() << " : leftHandSide is "
                 << leftHandSide.GetOrigin() << " and tolerance is " << eps;
     }
     result = false;
   }
 
   // Compare Axis and Extents
   for (unsigned int i = 0; i < 3; ++i)
   {
     if (!mitk::Equal(leftHandSide.GetAxisVector(i), rightHandSide.GetAxisVector(i), eps))
     {
       if (verbose)
       {
         MITK_INFO << "[( Geometry3D )] AxisVector #" << i << " differ";
         MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetAxisVector(i) << " : leftHandSide is "
                   << leftHandSide.GetAxisVector(i) << " and tolerance is " << eps;
       }
       result = false;
     }
 
     if (!mitk::Equal(leftHandSide.GetExtent(i), rightHandSide.GetExtent(i), eps))
     {
       if (verbose)
       {
         MITK_INFO << "[( Geometry3D )] Extent #" << i << " differ";
         MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetExtent(i) << " : leftHandSide is "
                   << leftHandSide.GetExtent(i) << " and tolerance is " << eps;
       }
       result = false;
     }
   }
 
   // Compare ImageGeometry Flag
   if (rightHandSide.GetImageGeometry() != leftHandSide.GetImageGeometry())
   {
     if (verbose)
     {
       MITK_INFO << "[( Geometry3D )] GetImageGeometry is different.";
       MITK_INFO << "rightHandSide is " << rightHandSide.GetImageGeometry() << " : leftHandSide is "
                 << leftHandSide.GetImageGeometry();
     }
     result = false;
   }
 
   // Compare FrameOfReference ID
   if (rightHandSide.GetFrameOfReferenceID() != leftHandSide.GetFrameOfReferenceID())
   {
     if (verbose)
     {
       MITK_INFO << "[( Geometry3D )] GetFrameOfReferenceID is different.";
       MITK_INFO << "rightHandSide is " << rightHandSide.GetFrameOfReferenceID() << " : leftHandSide is "
                 << leftHandSide.GetFrameOfReferenceID();
     }
     result = false;
   }
 
   // Compare BoundingBoxes
   if (!mitk::Equal(*leftHandSide.GetBoundingBox(), *rightHandSide.GetBoundingBox(), eps, verbose))
   {
     result = false;
   }
 
   // Compare IndexToWorldTransform Matrix
   if (!mitk::Equal(*leftHandSide.GetIndexToWorldTransform(), *rightHandSide.GetIndexToWorldTransform(), eps, verbose))
   {
     result = false;
   }
   return result;
 }
 
 bool mitk::Equal(const mitk::BaseGeometry::TransformType *leftHandSide,
                  const mitk::BaseGeometry::TransformType *rightHandSide,
                  ScalarType eps,
                  bool verbose)
 {
   if ((leftHandSide == nullptr) || (rightHandSide == nullptr))
   {
     MITK_ERROR << "mitk::Equal(const Geometry3D::TransformType *leftHandSide, const Geometry3D::TransformType "
                   "*rightHandSide, ScalarType eps, bool verbose ) does not with nullptr pointer input.";
     return false;
   }
   return Equal(*leftHandSide, *rightHandSide, eps, verbose);
 }
 
 bool mitk::Equal(const mitk::BaseGeometry::TransformType &leftHandSide,
                  const mitk::BaseGeometry::TransformType &rightHandSide,
                  ScalarType eps,
                  bool verbose)
 {
   // Compare IndexToWorldTransform Matrix
   if (!mitk::MatrixEqualElementWise(leftHandSide.GetMatrix(), rightHandSide.GetMatrix(), eps))
   {
     if (verbose)
     {
       MITK_INFO << "[( Geometry3D::TransformType )] Index to World Transformation matrix differs.";
       MITK_INFO << "rightHandSide is " << setprecision(12) << rightHandSide.GetMatrix() << " : leftHandSide is "
                 << leftHandSide.GetMatrix() << " and tolerance is " << eps;
     }
     return false;
   }
   return true;
 }
+
+bool mitk::IsSubGeometry(const mitk::BaseGeometry& testGeo,
+  const mitk::BaseGeometry& referenceGeo,
+  ScalarType eps,
+  bool verbose)
+{
+  bool result = true;
+
+  // Compare spacings (must be equal)
+  const auto testedSpacing = testGeo.GetSpacing();
+  if (!mitk::Equal(testedSpacing, referenceGeo.GetSpacing(), eps))
+  {
+    if (verbose)
+    {
+      MITK_INFO << "[( Geometry3D )] Spacing differs.";
+      MITK_INFO << "testedGeometry is " << setprecision(12) << testedSpacing << " : referenceGeometry is "
+        << referenceGeo.GetSpacing() << " and tolerance is " << eps;
+    }
+    result = false;
+  }
+
+  // Compare ImageGeometry Flag (must be equal)
+  if (referenceGeo.GetImageGeometry() != testGeo.GetImageGeometry())
+  {
+    if (verbose)
+    {
+      MITK_INFO << "[( Geometry3D )] GetImageGeometry is different.";
+      MITK_INFO << "referenceGeo is " << referenceGeo.GetImageGeometry() << " : testGeo is "
+        << testGeo.GetImageGeometry();
+    }
+    result = false;
+  }
+
+  // Compare IndexToWorldTransform Matrix (must be equal -> same axis directions)
+  if (!Equal(*(testGeo.GetIndexToWorldTransform()), *(referenceGeo.GetIndexToWorldTransform()), eps, verbose))
+  {
+    result = false;
+  }
+
+  // Compare BoundingBoxes (must be <=, thus corners of the tests geom must be inside the reference)
+  for (int i = 0; i<8; ++i)
+  {
+    auto testCorner = testGeo.GetCornerPoint(i);
+    if (testGeo.GetImageGeometry())
+    {
+      //if it is an image geometry the upper bounds indicate the first index that is not inside
+      //the geometry. Thus we will get the lower corener of the "first" voxel outside,
+      //but we need the corner of the "last" voxel inside the test geometry.
+      //To achive that we supstract one spacing from each index elment that is constructed
+      //by an upper bound value (see implementation of BaseGeometry::GetCorner().
+      std::bitset<sizeof(int)> bs(i);
+      if (bs.test(0))
+      {
+        testCorner[2] -= testedSpacing[2];
+      }
+      if (bs.test(1))
+      {
+        testCorner[1] -= testedSpacing[1];
+      }
+      if (bs.test(2))
+      {
+        testCorner[0] -= testedSpacing[0];
+      }
+    }
+
+    if (!referenceGeo.IsInside(testCorner))
+    {
+      if (verbose)
+      {
+        MITK_INFO << "[( Geometry3D )] corner point is not inside. ";
+        MITK_INFO << "referenceGeo is " << setprecision(12) << referenceGeo << " : tested corner is "
+          << testGeo.GetCornerPoint(i);
+      }
+      result = false;
+    }
+  }
+
+  // check grid of test geometry is on the grid of the reference geometry. This is important as the
+  // boundingbox is only checked for containing the tested geometry, but if a corner (one is enough
+  // as we know that axis and spacing are equal) of the tested geometry is on the grid it is really
+  // a sub geometry (as they have the same spacing and axis).
+  auto cornerOffset = testGeo.GetCornerPoint(0) - referenceGeo.GetCornerPoint(0);
+  for (unsigned int i = 0; i < 3; ++i)
+  {
+    auto pixelCountContinous = cornerOffset[i] / testedSpacing[i];
+    auto pixelCount = std::round(pixelCountContinous);
+    if (std::abs(pixelCount - pixelCountContinous) > eps)
+    {
+      if (verbose)
+      {
+        MITK_INFO << "[( Geometry3D )] Tested geometry is not on the grid of the reference geometry. ";
+        MITK_INFO << "referenceGeo is " << setprecision(15) << referenceGeo << " : tested corner offset in pixels is "
+          << pixelCountContinous << " for axis "<<i;
+      }
+      result = false;
+    }
+  }
+
+  return result;
+}
diff --git a/Modules/Core/src/DataManagement/mitkNodePredicateSubGeometry.cpp b/Modules/Core/src/DataManagement/mitkNodePredicateSubGeometry.cpp
new file mode 100644
index 0000000000..fe55cc35a9
--- /dev/null
+++ b/Modules/Core/src/DataManagement/mitkNodePredicateSubGeometry.cpp
@@ -0,0 +1,57 @@
+/*============================================================================
+
+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 "mitkNodePredicateSubGeometry.h"
+#include "mitkDataNode.h"
+#include "mitkImage.h"
+
+mitk::NodePredicateSubGeometry::NodePredicateSubGeometry(const BaseGeometry* refGeometry, TimePointType relevantTimePoint)
+  : m_RefGeometry(refGeometry), m_TimePoint(relevantTimePoint), m_UseTimePoint(true), m_CheckPrecision(mitk::eps)
+{
+  if (m_RefGeometry.IsNull()) mitkThrow() << "Invalid constructor initialization. Reference base geometry instance is nullptr pointer.";
+}
+
+mitk::NodePredicateSubGeometry::NodePredicateSubGeometry(const BaseGeometry* refGeometry)
+  : m_RefGeometry(refGeometry), m_TimePoint(0), m_UseTimePoint(false), m_CheckPrecision(mitk::eps)
+{
+  if (m_RefGeometry.IsNull()) mitkThrow() << "Invalid constructor initialization. Reference base geometry instance is nullptr pointer.";
+}
+
+mitk::NodePredicateSubGeometry::~NodePredicateSubGeometry()
+{
+}
+
+bool mitk::NodePredicateSubGeometry::CheckNode(const mitk::DataNode *node) const
+{
+  if (node == nullptr)
+    mitkThrow() << "NodePredicateSubGeometry: invalid node";
+
+  const auto *data = node->GetData();
+  if (data)
+  {
+    if (nullptr != data && m_RefGeometry.IsNotNull())
+    { //check only one time point.
+      mitk::BaseGeometry::Pointer testGeometry = data->GetGeometry();
+      if (this->m_UseTimePoint)
+      {
+        testGeometry = data->GetTimeGeometry()->GetGeometryForTimePoint(m_TimePoint);
+      }
+
+      if (testGeometry.IsNotNull())
+      {
+        return IsSubGeometry(*testGeometry, *m_RefGeometry, this->m_CheckPrecision, false);
+      }
+    }
+  }
+
+  return false;
+}
diff --git a/Modules/Core/test/files.cmake b/Modules/Core/test/files.cmake
index 5efc282bfa..63b574f8ed 100644
--- a/Modules/Core/test/files.cmake
+++ b/Modules/Core/test/files.cmake
@@ -1,194 +1,195 @@
 # tests with no extra command line parameter
 set(MODULE_TESTS
   # IMPORTANT: If you plan to deactivate / comment out a test please write a bug number to the commented out line of code.
   #
   #     Example: #mitkMyTest #this test is commented out because of bug 12345
   #
   # It is important that the bug is open and that the test will be activated again before the bug is closed. This assures that
   # no test is forgotten after it was commented out. If there is no bug for your current problem, please add a new one and
   # mark it as critical.
 
   ################## DISABLED TESTS #################################################
   #mitkAbstractTransformGeometryTest.cpp #seems as tested class mitkExternAbstractTransformGeometry doesnt exist any more
   #mitkStateMachineContainerTest.cpp #rewrite test, indirect since no longer exported Bug 14529
   #mitkRegistrationBaseTest.cpp #tested class  mitkRegistrationBase doesn't exist any more
   #mitkSegmentationInterpolationTest.cpp #file doesn't exist!
   #mitkPipelineSmartPointerCorrectnessTest.cpp #file doesn't exist!
   #mitkITKThreadingTest.cpp #test outdated because itk::Semaphore was removed from ITK
   #mitkAbstractTransformPlaneGeometryTest.cpp #mitkVtkAbstractTransformPlaneGeometry doesn't exist any more
   #mitkTestUtilSharedLibrary.cpp #Linker problem with this test...
   #mitkTextOverlay2DSymbolsRenderingTest.cpp #Implementation of the tested feature is not finished yet. Ask Christoph or see bug 15104 for details.
 
   ################# RUNNING TESTS ###################################################
   mitkAccessByItkTest.cpp
   mitkCoreObjectFactoryTest.cpp
   mitkDataNodeTest.cpp
   mitkMaterialTest.cpp
   mitkActionTest.cpp
   mitkDispatcherTest.cpp
   mitkEnumerationPropertyTest.cpp
   mitkFileReaderRegistryTest.cpp
   #mitkFileWriterRegistryTest.cpp
   mitkFloatToStringTest.cpp
   mitkGenericPropertyTest.cpp
   mitkGeometry3DTest.cpp
   mitkGeometry3DEqualTest.cpp
   mitkGeometryDataIOTest.cpp
   mitkGeometryDataToSurfaceFilterTest.cpp
   mitkImageCastTest.cpp
   mitkImageDataItemTest.cpp
   mitkImageGeneratorTest.cpp
   mitkIOUtilTest.cpp
   mitkBaseDataTest.cpp
   mitkImportItkImageTest.cpp
   mitkGrabItkImageMemoryTest.cpp
   mitkInstantiateAccessFunctionTest.cpp
   mitkLevelWindowTest.cpp
   mitkMessageTest.cpp
   mitkPixelTypeTest.cpp
   mitkPlaneGeometryTest.cpp
   mitkPointSetTest.cpp
   mitkPointSetEqualTest.cpp
   mitkPointSetFileIOTest.cpp
   mitkPointSetOnEmptyTest.cpp
   mitkPointSetLocaleTest.cpp
   mitkPointSetWriterTest.cpp
   mitkPointSetPointOperationsTest.cpp
   mitkProgressBarTest.cpp
   mitkPropertyTest.cpp
   mitkPropertyListTest.cpp
   mitkPropertyPersistenceTest.cpp
   mitkPropertyPersistenceInfoTest.cpp
   mitkPropertyRelationRuleBaseTest.cpp
   mitkPropertyRelationsTest.cpp
   mitkSlicedGeometry3DTest.cpp
   mitkSliceNavigationControllerTest.cpp
   mitkSurfaceTest.cpp
   mitkSurfaceEqualTest.cpp
   mitkSurfaceToSurfaceFilterTest.cpp
   mitkTimeGeometryTest.cpp
   mitkProportionalTimeGeometryTest.cpp
   mitkUndoControllerTest.cpp
   mitkVtkWidgetRenderingTest.cpp
   mitkVerboseLimitedLinearUndoTest.cpp
   mitkWeakPointerTest.cpp
   mitkTransferFunctionTest.cpp
   mitkStepperTest.cpp
   mitkRenderingManagerTest.cpp
   mitkCompositePixelValueToStringTest.cpp
   vtkMitkThickSlicesFilterTest.cpp
   mitkNodePredicateSourceTest.cpp
   mitkNodePredicateDataPropertyTest.cpp
   mitkNodePredicateFunctionTest.cpp
   mitkVectorTest.cpp
   mitkClippedSurfaceBoundsCalculatorTest.cpp
   mitkExceptionTest.cpp
   mitkExtractSliceFilterTest.cpp
   mitkLogTest.cpp
   mitkImageDimensionConverterTest.cpp
   mitkLoggingAdapterTest.cpp
   mitkUIDGeneratorTest.cpp
   mitkPlanePositionManagerTest.cpp
   mitkAffineTransformBaseTest.cpp
   mitkPropertyAliasesTest.cpp
   mitkPropertyDescriptionsTest.cpp
   mitkPropertyExtensionsTest.cpp
   mitkPropertyFiltersTest.cpp
   mitkPropertyKeyPathTest.cpp
   mitkTinyXMLTest.cpp
   mitkRawImageFileReaderTest.cpp
   mitkInteractionEventTest.cpp
   mitkLookupTableTest.cpp
   mitkSTLFileReaderTest.cpp
   mitkPointTypeConversionTest.cpp
   mitkVectorTypeConversionTest.cpp
   mitkMatrixTypeConversionTest.cpp
   mitkArrayTypeConversionTest.cpp
   mitkSurfaceToImageFilterTest.cpp
   mitkBaseGeometryTest.cpp
   mitkImageToSurfaceFilterTest.cpp
   mitkEqualTest.cpp
   mitkLineTest.cpp
   mitkArbitraryTimeGeometryTest.cpp
   mitkItkImageIOTest.cpp
   mitkLevelWindowManagerCppUnitTest.cpp
   mitkVectorPropertyTest.cpp
   mitkTemporoSpatialStringPropertyTest.cpp
   mitkPropertyNameHelperTest.cpp
   mitkNodePredicateGeometryTest.cpp
+  mitkNodePredicateSubGeometryTest.cpp
   mitkPreferenceListReaderOptionsFunctorTest.cpp
   mitkGenericIDRelationRuleTest.cpp
   mitkSourceImageRelationRuleTest.cpp
   mitkPointSetDataInteractorTest.cpp #since mitkInteractionTestHelper is currently creating a vtkRenderWindow
   mitkSurfaceVtkMapper2DTest.cpp #new rendering test in CppUnit style
   mitkSurfaceVtkMapper2D3DTest.cpp # comparisons/consistency 2D/3D
   mitkTemporalJoinImagesFilterTest.cpp
 )
 
 # test with image filename as an extra command line parameter
 set(MODULE_IMAGE_TESTS
   mitkImageTimeSelectorTest.cpp #only runs on images
   mitkImageAccessorTest.cpp #only runs on images
 )
 
 set(MODULE_SURFACE_TESTS
   mitkSurfaceVtkWriterTest.cpp #only runs on surfaces
 )
 
 # list of images for which the tests are run
 set(MODULE_TESTIMAGE
   US4DCyl.nrrd
   Pic3D.nrrd
   Pic2DplusT.nrrd
   BallBinary30x30x30.nrrd
   Png2D-bw.png
 )
 set(MODULE_TESTSURFACE
   binary.stl
   ball.stl
 )
 
 set(MODULE_CUSTOM_TESTS
     mitkDataStorageTest.cpp
     mitkDataNodeTest.cpp
     mitkEventConfigTest.cpp
     mitkPointSetLocaleTest.cpp
     mitkImageTest.cpp
     mitkImageVtkMapper2DTest.cpp
     mitkImageVtkMapper2DLevelWindowTest.cpp
     mitkImageVtkMapper2DOpacityTest.cpp
     mitkImageVtkMapper2DResliceInterpolationPropertyTest.cpp
     mitkImageVtkMapper2DColorTest.cpp
     mitkImageVtkMapper2DSwivelTest.cpp
     mitkImageVtkMapper2DTransferFunctionTest.cpp
     mitkImageVtkMapper2DOpacityTransferFunctionTest.cpp
     mitkImageVtkMapper2DLookupTableTest.cpp
     mitkSurfaceVtkMapper3DTest.cpp
     mitkVolumeCalculatorTest.cpp
     mitkLevelWindowManagerTest.cpp
     mitkPointSetVtkMapper2DTest.cpp
     mitkPointSetVtkMapper2DImageTest.cpp
     mitkPointSetVtkMapper2DGlyphTypeTest.cpp
     mitkPointSetVtkMapper2DTransformedPointsTest.cpp
     mitkVTKRenderWindowSizeTest.cpp
     mitkMultiComponentImageDataComparisonFilterTest.cpp
     mitkImageToItkTest.cpp
     mitkImageSliceSelectorTest.cpp
     mitkPointSetReaderTest.cpp
     mitkImageEqualTest.cpp
     mitkRotatedSlice4DTest.cpp
     mitkPlaneGeometryDataMapper2DTest.cpp
 )
 
 # Currently not working on windows because of a rendering timing issue
 # see bug 18083 for details
 if(NOT WIN32)
  set(MODULE_CUSTOM_TESTS ${MODULE_CUSTOM_TESTS} mitkSurfaceDepthSortingTest.cpp)
 endif()
 
 set(RESOURCE_FILES
   Interactions/AddAndRemovePoints.xml
   Interactions/globalConfig.xml
   Interactions/StatemachineTest.xml
   Interactions/StatemachineConfigTest.xml
 )
diff --git a/Modules/Core/test/mitkBaseGeometryTest.cpp b/Modules/Core/test/mitkBaseGeometryTest.cpp
index 79af25a94d..07b5afaf36 100644
--- a/Modules/Core/test/mitkBaseGeometryTest.cpp
+++ b/Modules/Core/test/mitkBaseGeometryTest.cpp
@@ -1,1343 +1,1518 @@
 /*============================================================================
 
 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 "mitkTestingMacros.h"
 #include <mitkTestFixture.h>
 #include <mitkTestingConfig.h>
 
 #include <MitkCoreExports.h>
 #include <mitkBaseGeometry.h>
 #include <mitkCommon.h>
 #include <mitkOperationActor.h>
 
 #include <itkAffineGeometryFrame.h>
 #include <itkBoundingBox.h>
 #include <itkIndex.h>
 #include <itkQuaternionRigidTransform.h>
 #include <itkScalableAffineTransform.h>
 #include <mitkVector.h>
 #include <vtkMatrix4x4.h>
 #include <vtkMatrixToLinearTransform.h>
 
 #include <mitkImageCast.h>
 #include <mitkInteractionConst.h>
 #include <mitkMatrixConvert.h>
 #include <mitkRotationOperation.h>
 #include <mitkScaleOperation.h>
 
 class vtkMatrix4x4;
 class vtkMatrixToLinearTransform;
 class vtkLinearTransform;
 
 typedef itk::BoundingBox<unsigned long, 3, mitk::ScalarType> BoundingBox;
 typedef itk::BoundingBox<unsigned long, 3, mitk::ScalarType> BoundingBoxType;
 typedef BoundingBoxType::BoundsArrayType BoundsArrayType;
 typedef BoundingBoxType::Pointer BoundingBoxPointer;
 
 // Dummy instance of abstract base class
 class DummyTestClass : public mitk::BaseGeometry
 {
 public:
   DummyTestClass(){};
   DummyTestClass(const DummyTestClass &other) : BaseGeometry(other){};
   ~DummyTestClass() override{};
 
   mitkClassMacro(DummyTestClass, mitk::BaseGeometry);
   itkNewMacro(Self);
   mitkNewMacro1Param(Self, const Self &);
 
   itk::LightObject::Pointer InternalClone() const override
   {
     Self::Pointer newGeometry = new Self(*this);
     newGeometry->UnRegister();
     return newGeometry.GetPointer();
   }
 
 protected:
   void PrintSelf(std::ostream & /*os*/, itk::Indent /*indent*/) const override{};
   //##Documentation
   //## @brief Pre- and Post-functions are empty in BaseGeometry
   //##
   //## These virtual functions allow for a different beahiour in subclasses.
   //## Do implement them in every subclass of BaseGeometry. If not needed, use {}.
   //## If this class is inherited from a subclass of BaseGeometry, call {Superclass::Pre...();};, example:
   // SlicedGeometry3D class
   void PreSetSpacing(const mitk::Vector3D &/*aSpacing*/) override{};
 };
 
 class mitkBaseGeometryTestSuite : public mitk::TestFixture
 {
   // List of Tests
   CPPUNIT_TEST_SUITE(mitkBaseGeometryTestSuite);
 
   // Constructor
   MITK_TEST(TestConstructors);
   MITK_TEST(TestInitialize);
 
   // Set
   MITK_TEST(TestSetOrigin);
   MITK_TEST(TestSetBounds);
   MITK_TEST(TestSetFloatBounds);
   MITK_TEST(TestSetFloatBoundsDouble);
   MITK_TEST(TestSetFrameOfReferenceID);
   MITK_TEST(TestSetIndexToWorldTransform);
   MITK_TEST(TestSetIndexToWorldTransformWithoutChangingSpacing);
   MITK_TEST(TestSetIndexToWorldTransform_WithPointerToSameTransform);
   MITK_TEST(TestSetSpacing);
   MITK_TEST(TestTransferItkToVtkTransform);
   MITK_TEST(TestSetIndexToWorldTransformByVtkMatrix);
   MITK_TEST(TestSetIdentity);
   MITK_TEST(TestSetImageGeometry);
   // Equal
   MITK_TEST(Equal_CloneAndOriginal_ReturnsTrue);
   MITK_TEST(Equal_DifferentOrigin_ReturnsFalse);
   MITK_TEST(Equal_DifferentIndexToWorldTransform_ReturnsFalse);
   MITK_TEST(Equal_DifferentSpacing_ReturnsFalse);
   MITK_TEST(Equal_InputIsNull_ReturnsFalse);
   MITK_TEST(Equal_DifferentBoundingBox_ReturnsFalse);
   MITK_TEST(Equal_Transforms_MinorDifferences_And_Eps);
   // other Functions
   MITK_TEST(TestComposeTransform);
   MITK_TEST(TestComposeVtkMatrix);
   MITK_TEST(TestTranslate);
   MITK_TEST(TestIndexToWorld);
   MITK_TEST(TestExecuteOperation);
   MITK_TEST(TestCalculateBoundingBoxRelToTransform);
   // MITK_TEST(TestSetTimeBounds);
   MITK_TEST(TestIs2DConvertable);
   MITK_TEST(TestGetCornerPoint);
   MITK_TEST(TestExtentInMM);
   MITK_TEST(TestGetAxisVector);
   MITK_TEST(TestGetCenter);
   MITK_TEST(TestGetDiagonalLength);
   MITK_TEST(TestGetExtent);
   MITK_TEST(TestIsInside);
   MITK_TEST(TestGetMatrixColumn);
+  // test IsSubGeometry
+  MITK_TEST(IsSubGeometry_Spacing);
+  MITK_TEST(IsSubGeometry_TransformMatrix);
+  MITK_TEST(IsSubGeometry_Bounds);
+  MITK_TEST(IsSubGeometry_Grid);
 
   CPPUNIT_TEST_SUITE_END();
 
   // Used Variables
 private:
   mitk::Point3D aPoint;
   float aFloatSpacing[3];
   mitk::Vector3D aSpacing;
   mitk::AffineTransform3D::Pointer aTransform;
   BoundingBoxPointer aBoundingBox;
   mitk::AffineTransform3D::MatrixType aMatrix;
 
   mitk::Point3D anotherPoint;
   mitk::Vector3D anotherSpacing;
   BoundingBoxPointer anotherBoundingBox;
   BoundingBoxPointer aThirdBoundingBox;
   mitk::AffineTransform3D::Pointer anotherTransform;
   mitk::AffineTransform3D::Pointer aThirdTransform;
   mitk::AffineTransform3D::MatrixType anotherMatrix;
   mitk::AffineTransform3D::MatrixType aThirdMatrix;
 
   DummyTestClass::Pointer aDummyGeometry;
   DummyTestClass::Pointer anotherDummyGeometry;
 
 public:
   // Set up for variables
   void setUp() override
   {
     mitk::FillVector3D(aFloatSpacing, 1, 1, 1);
     mitk::FillVector3D(aSpacing, 1, 1, 1);
     mitk::FillVector3D(aPoint, 0, 0, 0);
 
     // Transform
     aTransform = mitk::AffineTransform3D::New();
     aTransform->SetIdentity();
 
     aMatrix.SetIdentity();
 
     anotherTransform = mitk::AffineTransform3D::New();
 
     anotherMatrix.SetIdentity();
     anotherMatrix(1, 1) = 2;
     anotherTransform->SetMatrix(anotherMatrix);
 
     aThirdTransform = mitk::AffineTransform3D::New();
 
     aThirdMatrix.SetIdentity();
     aThirdMatrix(1, 1) = 7;
     aThirdTransform->SetMatrix(aThirdMatrix);
 
     // Bounding Box
     float bounds[6] = {0, 1, 0, 1, 0, 1};
     mitk::BoundingBox::BoundsArrayType b;
     const float *input = bounds;
     int j = 0;
     for (mitk::BoundingBox::BoundsArrayType::Iterator it = b.Begin(); j < 6; ++j)
       *it++ = (mitk::ScalarType)*input++;
 
     aBoundingBox = BoundingBoxType::New();
 
     BoundingBoxType::PointsContainer::Pointer pointscontainer = BoundingBoxType::PointsContainer::New();
     BoundingBoxType::PointType p;
     BoundingBoxType::PointIdentifier pointid;
     for (pointid = 0; pointid < 2; ++pointid)
     {
       unsigned int i;
       for (i = 0; i < 3; ++i)
       {
         p[i] = bounds[2 * i + pointid];
       }
       pointscontainer->InsertElement(pointid, p);
     }
 
     aBoundingBox->SetPoints(pointscontainer);
     aBoundingBox->ComputeBoundingBox();
 
     anotherBoundingBox = BoundingBoxType::New();
     p[0] = 11;
     p[1] = 12;
     p[2] = 13;
     pointscontainer->InsertElement(1, p);
     anotherBoundingBox->SetPoints(pointscontainer);
     anotherBoundingBox->ComputeBoundingBox();
 
     aThirdBoundingBox = BoundingBoxType::New();
     p[0] = 22;
     p[1] = 23;
     p[2] = 24;
     pointscontainer->InsertElement(1, p);
     aThirdBoundingBox->SetPoints(pointscontainer);
     aThirdBoundingBox->ComputeBoundingBox();
 
     mitk::FillVector3D(anotherPoint, 2, 3, 4);
     mitk::FillVector3D(anotherSpacing, 5, 6.5, 7);
 
     aDummyGeometry = DummyTestClass::New();
     aDummyGeometry->Initialize();
     anotherDummyGeometry = aDummyGeometry->Clone();
   }
 
   void tearDown() override
   {
     aDummyGeometry = nullptr;
     anotherDummyGeometry = nullptr;
   }
 
   // Test functions
 
   void TestSetOrigin()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetOrigin(anotherPoint);
     CPPUNIT_ASSERT(mitk::Equal(anotherPoint, dummy->GetOrigin()));
 
     // undo changes, new and changed object need to be the same!
     dummy->SetOrigin(aPoint);
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     MITK_ASSERT_EQUAL(dummy, newDummy, "TestSetOrigin");
   }
 
   void TestSetImageGeometry()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetImageGeometry(true);
     CPPUNIT_ASSERT(dummy->GetImageGeometry());
 
     // undo changes, new and changed object need to be the same!
     dummy->SetImageGeometry(false);
     CPPUNIT_ASSERT(dummy->GetImageGeometry() == false);
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     MITK_ASSERT_EQUAL(dummy, newDummy, "TestSetImageGeometry");
   }
 
   void TestSetFloatBounds()
   {
     float bounds[6] = {0, 11, 0, 12, 0, 13};
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetFloatBounds(bounds);
     MITK_ASSERT_EQUAL(BoundingBox::ConstPointer(dummy->GetBoundingBox()), anotherBoundingBox, "BoundingBox equality");
 
     // Wrong bounds, test needs to fail
     bounds[1] = 7;
     dummy->SetFloatBounds(bounds);
     MITK_ASSERT_NOT_EQUAL(
       BoundingBox::ConstPointer(dummy->GetBoundingBox()), anotherBoundingBox, "BoundingBox not equal");
 
     // undo changes, new and changed object need to be the same!
     float originalBounds[6] = {0, 1, 0, 1, 0, 1};
     dummy->SetFloatBounds(originalBounds);
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     MITK_ASSERT_EQUAL(dummy, newDummy, "Undo and equal");
   }
 
   void TestSetBounds()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetBounds(anotherBoundingBox->GetBounds());
     MITK_ASSERT_EQUAL(BoundingBox::ConstPointer(dummy->GetBoundingBox()), anotherBoundingBox, "Setting bounds");
 
     // Test needs to fail now
     dummy->SetBounds(aThirdBoundingBox->GetBounds());
     MITK_ASSERT_NOT_EQUAL(
       BoundingBox::ConstPointer(dummy->GetBoundingBox()), anotherBoundingBox, "Setting unequal bounds");
 
     // undo changes, new and changed object need to be the same!
     dummy->SetBounds(aBoundingBox->GetBounds());
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     MITK_ASSERT_EQUAL(dummy, newDummy, "Undo set bounds");
   }
 
   void TestSetFloatBoundsDouble()
   {
     double bounds[6] = {0, 11, 0, 12, 0, 13};
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetFloatBounds(bounds);
     MITK_ASSERT_EQUAL(BoundingBox::ConstPointer(dummy->GetBoundingBox()), anotherBoundingBox, "Float bounds");
 
     // Test needs to fail now
     bounds[3] = 7;
     dummy->SetFloatBounds(bounds);
     MITK_ASSERT_NOT_EQUAL(
       BoundingBox::ConstPointer(dummy->GetBoundingBox()), anotherBoundingBox, "Float bounds unequal");
 
     // undo changes, new and changed object need to be the same!
     double originalBounds[6] = {0, 1, 0, 1, 0, 1};
     dummy->SetFloatBounds(originalBounds);
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     MITK_ASSERT_EQUAL(dummy, newDummy, "Undo set float bounds");
   }
 
   void TestSetFrameOfReferenceID()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetFrameOfReferenceID(5);
     CPPUNIT_ASSERT(dummy->GetFrameOfReferenceID() == 5);
 
     // undo changes, new and changed object need to be the same!
     dummy->SetFrameOfReferenceID(0);
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     MITK_ASSERT_EQUAL(dummy, newDummy, "Undo set frame of reference");
   }
 
   void TestSetIndexToWorldTransform()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetIndexToWorldTransform(anotherTransform);
     MITK_ASSERT_EQUAL(anotherTransform,
                       mitk::AffineTransform3D::Pointer(dummy->GetIndexToWorldTransform()),
                       "Compare IndexToWorldTransform 1");
 
     // Test needs to fail now
     dummy->SetIndexToWorldTransform(aThirdTransform);
     MITK_ASSERT_NOT_EQUAL(anotherTransform,
                           mitk::AffineTransform3D::Pointer(dummy->GetIndexToWorldTransform()),
                           "Compare IndexToWorldTransform 2");
 
     // undo changes, new and changed object need to be the same!
     dummy->SetIndexToWorldTransform(aTransform);
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     MITK_ASSERT_EQUAL(dummy, newDummy, "Compare IndexToWorldTransform 3");
   }
 
   void TestSetIndexToWorldTransformWithoutChangingSpacing()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetIndexToWorldTransformWithoutChangingSpacing(anotherTransform);
     CPPUNIT_ASSERT(mitk::Equal(aSpacing, dummy->GetSpacing(), mitk::eps, true));
 
     // calculate a new version of anotherTransform, so that the spacing should be the same as the original spacing of
     // aTransform.
     mitk::AffineTransform3D::MatrixType::InternalMatrixType vnlmatrix;
     vnlmatrix = anotherTransform->GetMatrix().GetVnlMatrix();
 
     mitk::VnlVector col;
     col = vnlmatrix.get_column(0);
     col.normalize();
     col *= aSpacing[0];
     vnlmatrix.set_column(0, col);
     col = vnlmatrix.get_column(1);
     col.normalize();
     col *= aSpacing[1];
     vnlmatrix.set_column(1, col);
     col = vnlmatrix.get_column(2);
     col.normalize();
     col *= aSpacing[2];
     vnlmatrix.set_column(2, col);
 
     mitk::Matrix3D matrix;
     matrix = vnlmatrix;
     anotherTransform->SetMatrix(matrix);
 
     CPPUNIT_ASSERT(mitk::Equal(anotherTransform, dummy->GetIndexToWorldTransform(), mitk::eps, true));
   }
 
   void TestSetIndexToWorldTransform_WithPointerToSameTransform()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
 
     dummy->SetOrigin(anotherPoint);
     dummy->SetIndexToWorldTransform(anotherTransform);
     dummy->SetSpacing(anotherSpacing);
 
     mitk::AffineTransform3D::Pointer testTransfrom = dummy->GetIndexToWorldTransform();
 
     mitk::Vector3D modifiedPoint = anotherPoint.GetVectorFromOrigin() * 2.;
 
     testTransfrom->SetOffset(modifiedPoint);
 
     dummy->SetIndexToWorldTransform(testTransfrom);
 
     CPPUNIT_ASSERT(mitk::Equal(modifiedPoint, dummy->GetOrigin().GetVectorFromOrigin()));
   }
 
   void TestSetIndexToWorldTransformByVtkMatrix()
   {
     vtkMatrix4x4 *vtkmatrix;
     vtkmatrix = vtkMatrix4x4::New();
     vtkmatrix->Identity();
     vtkmatrix->SetElement(1, 1, 2);
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetIndexToWorldTransformByVtkMatrix(vtkmatrix);
     MITK_ASSERT_EQUAL(anotherTransform,
                       mitk::AffineTransform3D::Pointer(dummy->GetIndexToWorldTransform()),
                       "Compare IndexToWorldTransformByVtkMatrix 1");
 
     // test needs to fail now
     vtkmatrix->SetElement(1, 1, 7);
     dummy->SetIndexToWorldTransformByVtkMatrix(vtkmatrix);
     MITK_ASSERT_NOT_EQUAL(anotherTransform,
                           mitk::AffineTransform3D::Pointer(dummy->GetIndexToWorldTransform()),
                           "Compare IndexToWorldTransformByVtkMatrix 2");
 
     // undo changes, new and changed object need to be the same!
     vtkmatrix->SetElement(1, 1, 1);
     dummy->SetIndexToWorldTransformByVtkMatrix(vtkmatrix);
     vtkmatrix->Delete();
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     MITK_ASSERT_EQUAL(dummy, newDummy, "Compare IndexToWorldTransformByVtkMatrix 3");
   }
 
   void TestSetIdentity()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     // Change IndextoWorldTransform and Origin
     dummy->SetIndexToWorldTransform(anotherTransform);
     dummy->SetOrigin(anotherPoint);
 
     // Set Identity should reset ITWT and Origin
     dummy->SetIdentity();
 
     MITK_ASSERT_EQUAL(
       aTransform, mitk::AffineTransform3D::Pointer(dummy->GetIndexToWorldTransform()), "Test set identity 1");
     CPPUNIT_ASSERT(mitk::Equal(aPoint, dummy->GetOrigin()));
     CPPUNIT_ASSERT(mitk::Equal(aSpacing, dummy->GetSpacing()));
 
     // new and changed object need to be the same!
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     MITK_ASSERT_EQUAL(dummy, newDummy, "Test set identity 2");
   }
 
   void TestSetSpacing()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetSpacing(anotherSpacing);
     CPPUNIT_ASSERT(mitk::Equal(anotherSpacing, dummy->GetSpacing()));
 
     // undo changes, new and changed object need to be the same!
     dummy->SetSpacing(aSpacing);
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     MITK_ASSERT_EQUAL(dummy, newDummy, "Dummy spacing");
   }
 
   void TestTransferItkToVtkTransform()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetIndexToWorldTransform(anotherTransform); // calls TransferItkToVtkTransform
     mitk::AffineTransform3D::Pointer dummyTransform = dummy->GetIndexToWorldTransform();
     CPPUNIT_ASSERT(mitk::MatrixEqualElementWise(anotherMatrix, dummyTransform->GetMatrix()));
   }
 
   void TestConstructors()
   {
     // test standard constructor
     DummyTestClass::Pointer dummy1 = DummyTestClass::New();
     bool test = dummy1->IsValid();
     CPPUNIT_ASSERT(test == true);
     CPPUNIT_ASSERT(dummy1->GetFrameOfReferenceID() == 0);
     CPPUNIT_ASSERT(dummy1->GetIndexToWorldTransformLastModified() == 0);
 
     CPPUNIT_ASSERT(mitk::Equal(dummy1->GetSpacing(), aSpacing));
     CPPUNIT_ASSERT(mitk::Equal(dummy1->GetOrigin(), aPoint));
 
     CPPUNIT_ASSERT(dummy1->GetImageGeometry() == false);
 
     MITK_ASSERT_EQUAL(
       mitk::AffineTransform3D::Pointer(dummy1->GetIndexToWorldTransform()), aTransform, "Contructor test 1");
 
     MITK_ASSERT_EQUAL(
       mitk::BaseGeometry::BoundingBoxType::ConstPointer(dummy1->GetBoundingBox()), aBoundingBox, "Constructor test 2");
 
     DummyTestClass::Pointer dummy2 = DummyTestClass::New();
     dummy2->SetOrigin(anotherPoint);
     float bounds[6] = {0, 11, 0, 12, 0, 13};
     dummy2->SetFloatBounds(bounds);
     dummy2->SetIndexToWorldTransform(anotherTransform);
     dummy2->SetSpacing(anotherSpacing);
 
     DummyTestClass::Pointer dummy3 = DummyTestClass::New(*dummy2);
     MITK_ASSERT_EQUAL(dummy3, dummy2, "Dummy contructor");
   }
 
   // Equal Tests
 
   void Equal_CloneAndOriginal_ReturnsTrue() { MITK_ASSERT_EQUAL(aDummyGeometry, anotherDummyGeometry, "Clone test"); }
   void Equal_DifferentOrigin_ReturnsFalse()
   {
     anotherDummyGeometry->SetOrigin(anotherPoint);
 
     MITK_ASSERT_NOT_EQUAL(aDummyGeometry, anotherDummyGeometry, "Different origin test");
   }
 
   void Equal_DifferentIndexToWorldTransform_ReturnsFalse()
   {
     anotherDummyGeometry->SetIndexToWorldTransform(anotherTransform);
 
     MITK_ASSERT_NOT_EQUAL(aDummyGeometry, anotherDummyGeometry, "Different index to world");
   }
 
   void Equal_DifferentSpacing_ReturnsFalse()
   {
     anotherDummyGeometry->SetSpacing(anotherSpacing);
 
     MITK_ASSERT_NOT_EQUAL(aDummyGeometry, anotherDummyGeometry, "Different spacing");
   }
 
   void Equal_InputIsNull_ReturnsFalse()
   {
     DummyTestClass::Pointer geometryNull = nullptr;
     CPPUNIT_ASSERT_THROW(MITK_ASSERT_EQUAL(geometryNull, anotherDummyGeometry, "Input is null"), mitk::Exception);
   }
 
   void Equal_DifferentBoundingBox_ReturnsFalse()
   {
     // create different bounds to make the comparison false
     mitk::ScalarType bounds[] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
     anotherDummyGeometry->SetBounds(bounds);
 
     MITK_ASSERT_NOT_EQUAL(aDummyGeometry, anotherDummyGeometry, "Different bounding box");
   }
 
   void Equal_Transforms_MinorDifferences_And_Eps()
   {
     // Verifies that the eps parameter is evaluated properly
     // when comparing two mitk::BaseGeometry::TransformTypes
     aMatrix.SetIdentity();
     anotherMatrix.SetIdentity();
 
     aMatrix(0, 1) = 0.0002;
     aTransform->SetMatrix(aMatrix);
     anotherMatrix(0, 1) = 0.0002;
     anotherTransform->SetMatrix(anotherMatrix);
     anotherTransform->SetMatrix(aMatrix);
     CPPUNIT_ASSERT_MESSAGE("Exact same transforms are mitk::Equal() for eps=mitk::eps",
                            mitk::Equal(aTransform, anotherTransform, mitk::eps, true));
     CPPUNIT_ASSERT_MESSAGE("Exact same transforms are mitk::Equal() for eps=vnl_math::eps",
                            mitk::Equal(aTransform, anotherTransform, vnl_math::eps, true));
 
     anotherMatrix(0, 1) = 0.0002 + mitk::eps;
     anotherTransform->SetMatrix(anotherMatrix);
     CPPUNIT_ASSERT_MESSAGE("Transforms of diff mitk::eps are !mitk::Equal() for eps=vnl_math::eps",
                            !mitk::Equal(aTransform, anotherTransform, vnl_math::eps, true));
     CPPUNIT_ASSERT_MESSAGE("Transforms of diff mitk::eps are !mitk::Equal() for eps=mitk::eps-1%",
                            !mitk::Equal(aTransform, anotherTransform, mitk::eps * 0.99, true));
     CPPUNIT_ASSERT_MESSAGE("Transforms of diff mitk::eps _are_ mitk::Equal() for eps=mitk::eps+1%",
                            mitk::Equal(aTransform, anotherTransform, mitk::eps * 1.01, true));
   }
 
   void TestComposeTransform()
   {
     // Create Transformations to set and compare
     mitk::AffineTransform3D::Pointer transform1;
     transform1 = mitk::AffineTransform3D::New();
     mitk::AffineTransform3D::MatrixType matrix1;
     matrix1.SetIdentity();
     matrix1(1, 1) = 2;
     transform1->SetMatrix(matrix1); // Spacing = 2
 
     mitk::AffineTransform3D::Pointer transform2;
     transform2 = mitk::AffineTransform3D::New();
     mitk::AffineTransform3D::MatrixType matrix2;
     matrix2.SetIdentity();
     matrix2(1, 1) = 2;
     transform2->SetMatrix(matrix2); // Spacing = 2
 
     mitk::AffineTransform3D::Pointer transform3;
     transform3 = mitk::AffineTransform3D::New();
     mitk::AffineTransform3D::MatrixType matrix3;
     matrix3.SetIdentity();
     matrix3(1, 1) = 4;
     transform3->SetMatrix(matrix3); // Spacing = 4
 
     mitk::AffineTransform3D::Pointer transform4;
     transform4 = mitk::AffineTransform3D::New();
     mitk::AffineTransform3D::MatrixType matrix4;
     matrix4.SetIdentity();
     matrix4(1, 1) = 0.25;
     transform4->SetMatrix(matrix4); // Spacing = 0.25
 
     // Vector to compare spacing
     mitk::Vector3D expectedSpacing;
     expectedSpacing.Fill(1.0);
     expectedSpacing[1] = 4;
 
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetIndexToWorldTransform(transform1); // Spacing = 2
     dummy->Compose(transform2);                  // Spacing = 4
     CPPUNIT_ASSERT(mitk::Equal(dummy->GetSpacing(), expectedSpacing));
     MITK_ASSERT_EQUAL(
       transform3, mitk::AffineTransform3D::Pointer(dummy->GetIndexToWorldTransform()), "Compose transform 2"); // 4=4
 
     // undo changes, new and changed object need to be the same!
     dummy->Compose(transform4); // Spacing = 1
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     MITK_ASSERT_EQUAL(dummy, newDummy, "Compose transform 3"); // 1=1
   }
 
   void TestComposeVtkMatrix()
   {
     // Create Transformations to set and compare
     mitk::AffineTransform3D::Pointer transform1;
     transform1 = mitk::AffineTransform3D::New();
     mitk::AffineTransform3D::MatrixType matrix1;
     matrix1.SetIdentity();
     matrix1(1, 1) = 2;
     transform1->SetMatrix(matrix1); // Spacing = 2
 
     vtkMatrix4x4 *vtkmatrix2;
     vtkmatrix2 = vtkMatrix4x4::New();
     vtkmatrix2->Identity();
     vtkmatrix2->SetElement(1, 1, 2); // Spacing = 2
 
     mitk::AffineTransform3D::Pointer transform3;
     transform3 = mitk::AffineTransform3D::New();
     mitk::AffineTransform3D::MatrixType matrix3;
     matrix3.SetIdentity();
     matrix3(1, 1) = 4;
     transform3->SetMatrix(matrix3); // Spacing = 4
 
     vtkMatrix4x4 *vtkmatrix4;
     vtkmatrix4 = vtkMatrix4x4::New();
     vtkmatrix4->Identity();
     vtkmatrix4->SetElement(1, 1, 0.25); // Spacing = 0.25
 
     // Vector to compare spacing
     mitk::Vector3D expectedSpacing;
     expectedSpacing.Fill(1.0);
     expectedSpacing[1] = 4;
 
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetIndexToWorldTransform(transform1); // Spacing = 2
     dummy->Compose(vtkmatrix2);                  // Spacing = 4
     vtkmatrix2->Delete();
 
     MITK_ASSERT_EQUAL(
       transform3, mitk::AffineTransform3D::Pointer(dummy->GetIndexToWorldTransform()), "Compose vtk matrix"); // 4=4
     CPPUNIT_ASSERT(mitk::Equal(dummy->GetSpacing(), expectedSpacing));
 
     // undo changes, new and changed object need to be the same!
     dummy->Compose(vtkmatrix4); // Spacing = 1
     vtkmatrix4->Delete();
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     MITK_ASSERT_EQUAL(dummy, newDummy, "Compose vtk"); // 1=1
   }
 
   void TestTranslate()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetOrigin(anotherPoint);
     CPPUNIT_ASSERT(mitk::Equal(anotherPoint, dummy->GetOrigin()));
 
     // use some random values for translation
     mitk::Vector3D translationVector;
     translationVector.SetElement(0, 17.5f);
     translationVector.SetElement(1, -32.3f);
     translationVector.SetElement(2, 4.0f);
 
     // compute ground truth
     mitk::Point3D tmpResult = anotherPoint + translationVector;
     dummy->Translate(translationVector);
     CPPUNIT_ASSERT(mitk::Equal(dummy->GetOrigin(), tmpResult));
 
     // undo changes
     translationVector *= -1;
     dummy->Translate(translationVector);
     CPPUNIT_ASSERT(mitk::Equal(dummy->GetOrigin(), anotherPoint));
 
     // undo changes, new and changed object need to be the same!
     translationVector.SetElement(0, -1 * anotherPoint[0]);
     translationVector.SetElement(1, -1 * anotherPoint[1]);
     translationVector.SetElement(2, -1 * anotherPoint[2]);
     dummy->Translate(translationVector);
 
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     MITK_ASSERT_EQUAL(dummy, newDummy, "Translate test");
   }
 
   // a part of the test requires axis-parallel coordinates
   int testIndexAndWorldConsistency(DummyTestClass::Pointer dummyGeometry)
   {
     // Testing consistency of index and world coordinate systems
     mitk::Point3D origin = dummyGeometry->GetOrigin();
     mitk::Point3D dummyPoint;
 
     // Testing index->world->index conversion consistency
     dummyGeometry->WorldToIndex(origin, dummyPoint);
     dummyGeometry->IndexToWorld(dummyPoint, dummyPoint);
     CPPUNIT_ASSERT(mitk::EqualArray(dummyPoint, origin, 3, mitk::eps, true));
 
     // Testing WorldToIndex(origin, mitk::Point3D)==(0,0,0)
     mitk::Point3D globalOrigin;
     mitk::FillVector3D(globalOrigin, 0, 0, 0);
 
     mitk::Point3D originContinuousIndex;
     dummyGeometry->WorldToIndex(origin, originContinuousIndex);
     CPPUNIT_ASSERT(mitk::EqualArray(originContinuousIndex, globalOrigin, 3, mitk::eps, true));
 
     // Testing WorldToIndex(origin, itk::Index)==(0,0,0)
     itk::Index<3> itkindex;
     dummyGeometry->WorldToIndex(origin, itkindex);
     itk::Index<3> globalOriginIndex;
     mitk::vtk2itk(globalOrigin, globalOriginIndex);
     CPPUNIT_ASSERT(mitk::EqualArray(itkindex, globalOriginIndex, 3, mitk::eps, true));
 
     // Testing WorldToIndex(origin-0.5*spacing, itk::Index)==(0,0,0)
     mitk::Vector3D halfSpacingStep = dummyGeometry->GetSpacing() * 0.5;
     mitk::Matrix3D rotation;
     mitk::Point3D originOffCenter = origin - halfSpacingStep;
     dummyGeometry->WorldToIndex(originOffCenter, itkindex);
     CPPUNIT_ASSERT(mitk::EqualArray(itkindex, globalOriginIndex, 3, mitk::eps, true));
 
     // Testing WorldToIndex(origin+0.5*spacing-eps, itk::Index)==(0,0,0)
     originOffCenter = origin + halfSpacingStep;
     originOffCenter -= 0.0001;
     dummyGeometry->WorldToIndex(originOffCenter, itkindex);
     CPPUNIT_ASSERT(mitk::EqualArray(itkindex, globalOriginIndex, 3, mitk::eps, true));
 
     // Testing WorldToIndex(origin+0.5*spacing, itk::Index)==(1,1,1)");
     originOffCenter = origin + halfSpacingStep;
     itk::Index<3> global111;
     mitk::FillVector3D(global111, 1, 1, 1);
     dummyGeometry->WorldToIndex(originOffCenter, itkindex);
     CPPUNIT_ASSERT(mitk::EqualArray(itkindex, global111, 3, mitk::eps, true));
 
     // Testing WorldToIndex(GetCenter())==BoundingBox.GetCenter
     mitk::Point3D center = dummyGeometry->GetCenter();
     mitk::Point3D centerContIndex;
     dummyGeometry->WorldToIndex(center, centerContIndex);
     mitk::BoundingBox::ConstPointer boundingBox = dummyGeometry->GetBoundingBox();
     mitk::BoundingBox::PointType centerBounds = boundingBox->GetCenter();
     CPPUNIT_ASSERT(mitk::Equal(centerContIndex, centerBounds));
 
     // Testing GetCenter()==IndexToWorld(BoundingBox.GetCenter)
     center = dummyGeometry->GetCenter();
     mitk::Point3D centerBoundsInWorldCoords;
     dummyGeometry->IndexToWorld(centerBounds, centerBoundsInWorldCoords);
     CPPUNIT_ASSERT(mitk::Equal(center, centerBoundsInWorldCoords));
 
     // Test using random point,
     // Testing consistency of index and world coordinate systems
     mitk::Point3D point;
     mitk::FillVector3D(point, 3.5, -2, 4.6);
 
     // Testing index->world->index conversion consistency
     dummyGeometry->WorldToIndex(point, dummyPoint);
     dummyGeometry->IndexToWorld(dummyPoint, dummyPoint);
     CPPUNIT_ASSERT(mitk::EqualArray(dummyPoint, point, 3, mitk::eps, true));
 
     return EXIT_SUCCESS;
   }
 
   int testIndexAndWorldConsistencyForVectors(DummyTestClass::Pointer dummyGeometry)
   {
     // Testing consistency of index and world coordinate systems for vectors
     mitk::Vector3D xAxisMM = dummyGeometry->GetAxisVector(0);
     mitk::Vector3D xAxisContinuousIndex;
 
     mitk::Point3D p, pIndex, origin;
     origin = dummyGeometry->GetOrigin();
     p[0] = xAxisMM[0] + origin[0];
     p[1] = xAxisMM[1] + origin[1];
     p[2] = xAxisMM[2] + origin[2];
 
     dummyGeometry->WorldToIndex(p, pIndex);
 
     dummyGeometry->WorldToIndex(xAxisMM, xAxisContinuousIndex);
     CPPUNIT_ASSERT(mitk::Equal(xAxisContinuousIndex[0], pIndex[0]));
     CPPUNIT_ASSERT(mitk::Equal(xAxisContinuousIndex[1], pIndex[1]));
     CPPUNIT_ASSERT(mitk::Equal(xAxisContinuousIndex[2], pIndex[2]));
 
     dummyGeometry->IndexToWorld(xAxisContinuousIndex, xAxisContinuousIndex);
 
     dummyGeometry->IndexToWorld(pIndex, p);
 
     CPPUNIT_ASSERT(xAxisContinuousIndex == xAxisMM);
     CPPUNIT_ASSERT(mitk::Equal(xAxisContinuousIndex[0], p[0] - origin[0]));
     CPPUNIT_ASSERT(mitk::Equal(xAxisContinuousIndex[1], p[1] - origin[1]));
     CPPUNIT_ASSERT(mitk::Equal(xAxisContinuousIndex[2], p[2] - origin[2]));
 
     // Test consictency for random vector
     mitk::Vector3D vector;
     mitk::FillVector3D(vector, 2.5, -3.2, 8.1);
     mitk::Vector3D vectorContinuousIndex;
 
     p[0] = vector[0] + origin[0];
     p[1] = vector[1] + origin[1];
     p[2] = vector[2] + origin[2];
 
     dummyGeometry->WorldToIndex(p, pIndex);
 
     dummyGeometry->WorldToIndex(vector, vectorContinuousIndex);
     CPPUNIT_ASSERT(mitk::Equal(vectorContinuousIndex[0], pIndex[0]));
     CPPUNIT_ASSERT(mitk::Equal(vectorContinuousIndex[1], pIndex[1]));
     CPPUNIT_ASSERT(mitk::Equal(vectorContinuousIndex[2], pIndex[2]));
 
     dummyGeometry->IndexToWorld(vectorContinuousIndex, vectorContinuousIndex);
 
     dummyGeometry->IndexToWorld(pIndex, p);
 
     CPPUNIT_ASSERT(vectorContinuousIndex == vector);
     CPPUNIT_ASSERT(mitk::Equal(vectorContinuousIndex[0], p[0] - origin[0]));
     CPPUNIT_ASSERT(mitk::Equal(vectorContinuousIndex[1], p[1] - origin[1]));
     CPPUNIT_ASSERT(mitk::Equal(vectorContinuousIndex[2], p[2] - origin[2]));
 
     return EXIT_SUCCESS;
   }
 
   int testIndexAndWorldConsistencyForIndex(DummyTestClass::Pointer dummyGeometry)
   {
     // Testing consistency of index and world coordinate systems
 
     // creating testing data
     itk::Index<4> itkIndex4, itkIndex4b;
     itk::Index<3> itkIndex3, itkIndex3b;
     itk::Index<2> itkIndex2, itkIndex2b;
     itk::Index<3> mitkIndex, mitkIndexb;
 
     itkIndex4[0] = itkIndex4[1] = itkIndex4[2] = itkIndex4[3] = 4;
     itkIndex3[0] = itkIndex3[1] = itkIndex3[2] = 6;
     itkIndex2[0] = itkIndex2[1] = 2;
     mitkIndex[0] = mitkIndex[1] = mitkIndex[2] = 13;
 
     // check for constistency
     mitk::Point3D point;
     dummyGeometry->IndexToWorld(itkIndex2, point);
     dummyGeometry->WorldToIndex(point, itkIndex2b);
 
     CPPUNIT_ASSERT(((itkIndex2b[0] == itkIndex2[0]) && (itkIndex2b[1] == itkIndex2[1])));
     // Testing itk::index<2> for IndexToWorld/WorldToIndex consistency
 
     dummyGeometry->IndexToWorld(itkIndex3, point);
     dummyGeometry->WorldToIndex(point, itkIndex3b);
 
     CPPUNIT_ASSERT(
       ((itkIndex3b[0] == itkIndex3[0]) && (itkIndex3b[1] == itkIndex3[1]) && (itkIndex3b[2] == itkIndex3[2])));
     // Testing itk::index<3> for IndexToWorld/WorldToIndex consistency
 
     dummyGeometry->IndexToWorld(itkIndex4, point);
     dummyGeometry->WorldToIndex(point, itkIndex4b);
 
     CPPUNIT_ASSERT(((itkIndex4b[0] == itkIndex4[0]) && (itkIndex4b[1] == itkIndex4[1]) &&
                     (itkIndex4b[2] == itkIndex4[2]) && (itkIndex4b[3] == 0)));
     // Testing itk::index<3> for IndexToWorld/WorldToIndex consistency
 
     dummyGeometry->IndexToWorld(mitkIndex, point);
     dummyGeometry->WorldToIndex(point, mitkIndexb);
 
     CPPUNIT_ASSERT(
       ((mitkIndexb[0] == mitkIndex[0]) && (mitkIndexb[1] == mitkIndex[1]) && (mitkIndexb[2] == mitkIndex[2])));
     // Testing mitk::Index for IndexToWorld/WorldToIndex consistency
 
     return EXIT_SUCCESS;
   }
 
   void TestIndexToWorld()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
 
     testIndexAndWorldConsistency(dummy);
     testIndexAndWorldConsistencyForVectors(dummy);
     testIndexAndWorldConsistencyForIndex(dummy);
 
     // Geometry must not have changed
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     MITK_ASSERT_EQUAL(dummy, newDummy, "Dummy index to world");
 
     // Test with other geometries
     dummy->SetOrigin(anotherPoint);
     testIndexAndWorldConsistency(dummy);
     testIndexAndWorldConsistencyForVectors(dummy);
     testIndexAndWorldConsistencyForIndex(dummy);
 
     dummy->SetIndexToWorldTransform(anotherTransform);
     testIndexAndWorldConsistency(dummy);
     testIndexAndWorldConsistencyForVectors(dummy);
     testIndexAndWorldConsistencyForIndex(dummy);
 
     dummy->SetOrigin(anotherPoint);
     testIndexAndWorldConsistency(dummy);
     testIndexAndWorldConsistencyForVectors(dummy);
     testIndexAndWorldConsistencyForIndex(dummy);
 
     dummy->SetSpacing(anotherSpacing);
     testIndexAndWorldConsistency(dummy);
     testIndexAndWorldConsistencyForVectors(dummy);
     testIndexAndWorldConsistencyForIndex(dummy);
   }
 
   void TestExecuteOperation()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
 
     // Do same Operations with new Dummy and compare
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
 
     // Test operation Nothing
     auto opN = new mitk::Operation(mitk::OpNOTHING);
     dummy->ExecuteOperation(opN);
     MITK_ASSERT_EQUAL(dummy, newDummy, "Dummy execute operation 1");
 
     // Test operation Move
     auto opP = new mitk::PointOperation(mitk::OpMOVE, anotherPoint);
     dummy->ExecuteOperation(opP);
     CPPUNIT_ASSERT(mitk::Equal(anotherPoint, dummy->GetOrigin()));
     newDummy->SetOrigin(anotherPoint);
     MITK_ASSERT_EQUAL(dummy, newDummy, "Dummy execute operation 2");
 
     // Test operation Scale, Scale sets spacing to scale+1
     mitk::Point3D spacing;
     spacing[0] = anotherSpacing[0] - 1.;
     spacing[1] = anotherSpacing[1] - 1.;
     spacing[2] = anotherSpacing[2] - 1.;
 
     auto opS = new mitk::ScaleOperation(mitk::OpSCALE, spacing, anotherPoint);
     dummy->ExecuteOperation(opS);
     CPPUNIT_ASSERT(mitk::Equal(anotherSpacing, dummy->GetSpacing()));
     newDummy->SetSpacing(anotherSpacing);
     MITK_ASSERT_EQUAL(dummy, newDummy, "Dummy execute operation 3");
 
     // change Geometry to test more cases
     dummy->SetIndexToWorldTransform(anotherTransform);
     dummy->SetSpacing(anotherSpacing);
 
     // Testing a rotation of the geometry
     double angle = 35.0;
     mitk::Vector3D rotationVector;
     mitk::FillVector3D(rotationVector, 1, 0, 0);
     mitk::Point3D center = dummy->GetCenter();
     auto opR = new mitk::RotationOperation(mitk::OpROTATE, center, rotationVector, angle);
     dummy->ExecuteOperation(opR);
 
     mitk::Matrix3D rotation;
     mitk::GetRotation(dummy, rotation);
     mitk::Vector3D voxelStep = rotation * anotherSpacing;
     mitk::Vector3D voxelStepIndex;
     dummy->WorldToIndex(voxelStep, voxelStepIndex);
     mitk::Vector3D expectedVoxelStepIndex;
     expectedVoxelStepIndex.Fill(1);
     CPPUNIT_ASSERT(mitk::Equal(voxelStepIndex, expectedVoxelStepIndex));
 
     delete opR;
     delete opN;
     delete opS;
     delete opP;
   }
 
   void TestCalculateBoundingBoxRelToTransform()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetExtentInMM(0, 15);
     dummy->SetExtentInMM(1, 20);
     dummy->SetExtentInMM(2, 8);
 
     mitk::BoundingBox::Pointer dummyBoundingBox = dummy->CalculateBoundingBoxRelativeToTransform(anotherTransform);
 
     mitk::BoundingBox::PointsContainer::Pointer pointscontainer = mitk::BoundingBox::PointsContainer::New();
     mitk::BoundingBox::PointIdentifier pointid = 0;
     unsigned char i;
     mitk::AffineTransform3D::Pointer inverse = mitk::AffineTransform3D::New();
     anotherTransform->GetInverse(inverse);
     for (i = 0; i < 8; ++i)
       pointscontainer->InsertElement(pointid++, inverse->TransformPoint(dummy->GetCornerPoint(i)));
     mitk::BoundingBox::Pointer result = mitk::BoundingBox::New();
     result->SetPoints(pointscontainer);
     result->ComputeBoundingBox();
 
     MITK_ASSERT_EQUAL(result, dummyBoundingBox, "BBox rel to transform");
 
     // dummy still needs to be unchanged, except for extend
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     newDummy->SetExtentInMM(0, 15);
     newDummy->SetExtentInMM(1, 20);
     newDummy->SetExtentInMM(2, 8);
     MITK_ASSERT_EQUAL(dummy, newDummy, "Dummy BBox");
   }
 
   // void TestSetTimeBounds(){
   //  mitk::TimeBounds timeBounds;
   //  timeBounds[0] = 1;
   //  timeBounds[1] = 9;
 
   //  DummyTestClass::Pointer dummy = DummyTestClass::New();
   //  dummy->SetTimeBounds(timeBounds);
   //  mitk::TimeBounds timeBounds2 = dummy->GetTimeBounds();
 
   //  CPPUNIT_ASSERT(timeBounds[0]==timeBounds2[0]);
   //  CPPUNIT_ASSERT(timeBounds[1]==timeBounds2[1]);
 
   //  //undo changes, new and changed object need to be the same!
   //  timeBounds[0]=mitk::ScalarTypeNumericTraits::NonpositiveMin();
   //  timeBounds[1]=mitk::ScalarTypeNumericTraits::max();
 
   //  DummyTestClass::Pointer newDummy = DummyTestClass::New();
   //  CPPUNIT_ASSERT(mitk::Equal(dummy,newDummy,mitk::eps,true));
   //}
 
   void TestIs2DConvertable()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
 
     // new initialized geometry is 2D convertable
     CPPUNIT_ASSERT(dummy->Is2DConvertable());
 
     // Wrong Spacing needs to fail
     dummy->SetSpacing(anotherSpacing);
     CPPUNIT_ASSERT(dummy->Is2DConvertable() == false);
     // undo
     dummy->SetSpacing(aSpacing);
     CPPUNIT_ASSERT(dummy->Is2DConvertable());
 
     // Wrong Origin needs to fail
     dummy->SetOrigin(anotherPoint);
     CPPUNIT_ASSERT(dummy->Is2DConvertable() == false);
     // undo
     dummy->SetOrigin(aPoint);
     CPPUNIT_ASSERT(dummy->Is2DConvertable());
 
     // third dimension must not be transformed
     mitk::AffineTransform3D::Pointer dummyTransform = mitk::AffineTransform3D::New();
     mitk::AffineTransform3D::MatrixType dummyMatrix;
     dummyMatrix.SetIdentity();
     dummyTransform->SetMatrix(dummyMatrix);
     dummy->SetIndexToWorldTransform(dummyTransform);
 
     // identity matrix is 2DConvertable
     CPPUNIT_ASSERT(dummy->Is2DConvertable());
 
     dummyMatrix(0, 2) = 3;
     dummyTransform->SetMatrix(dummyMatrix);
     CPPUNIT_ASSERT(dummy->Is2DConvertable() == false);
 
     dummyMatrix.SetIdentity();
     dummyMatrix(1, 2) = 0.4;
     dummyTransform->SetMatrix(dummyMatrix);
     CPPUNIT_ASSERT(dummy->Is2DConvertable() == false);
 
     dummyMatrix.SetIdentity();
     dummyMatrix(2, 2) = 3;
     dummyTransform->SetMatrix(dummyMatrix);
     CPPUNIT_ASSERT(dummy->Is2DConvertable() == false);
 
     dummyMatrix.SetIdentity();
     dummyMatrix(2, 1) = 3;
     dummyTransform->SetMatrix(dummyMatrix);
     CPPUNIT_ASSERT(dummy->Is2DConvertable() == false);
 
     dummyMatrix.SetIdentity();
     dummyMatrix(2, 0) = 3;
     dummyTransform->SetMatrix(dummyMatrix);
     CPPUNIT_ASSERT(dummy->Is2DConvertable() == false);
 
     // undo changes, new and changed object need to be the same!
     dummyMatrix.SetIdentity();
     dummyTransform->SetMatrix(dummyMatrix);
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     MITK_ASSERT_EQUAL(dummy, newDummy, "Is 2D convertable");
   }
 
   void TestGetCornerPoint()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetIndexToWorldTransform(anotherTransform);
     double bounds[6] = {0, 11, 0, 12, 0, 13};
     dummy->SetFloatBounds(bounds);
 
     mitk::Point3D corner, refCorner;
 
     // Corner 0
     mitk::FillVector3D(refCorner, bounds[0], bounds[2], bounds[4]);
     refCorner = anotherTransform->TransformPoint(refCorner);
     corner = dummy->GetCornerPoint(0);
     CPPUNIT_ASSERT(mitk::Equal(refCorner, corner));
     corner = dummy->GetCornerPoint(true, true, true);
     CPPUNIT_ASSERT(mitk::Equal(refCorner, corner));
 
     // Corner 1
     mitk::FillVector3D(refCorner, bounds[0], bounds[2], bounds[5]);
     refCorner = anotherTransform->TransformPoint(refCorner);
     corner = dummy->GetCornerPoint(1);
     CPPUNIT_ASSERT(mitk::Equal(refCorner, corner));
     corner = dummy->GetCornerPoint(true, true, false);
     CPPUNIT_ASSERT(mitk::Equal(refCorner, corner));
 
     // Corner 2
     mitk::FillVector3D(refCorner, bounds[0], bounds[3], bounds[4]);
     refCorner = anotherTransform->TransformPoint(refCorner);
     corner = dummy->GetCornerPoint(2);
     CPPUNIT_ASSERT(mitk::Equal(refCorner, corner));
     corner = dummy->GetCornerPoint(true, false, true);
     CPPUNIT_ASSERT(mitk::Equal(refCorner, corner));
 
     // Corner 3
     mitk::FillVector3D(refCorner, bounds[0], bounds[3], bounds[5]);
     refCorner = anotherTransform->TransformPoint(refCorner);
     corner = dummy->GetCornerPoint(3);
     CPPUNIT_ASSERT(mitk::Equal(refCorner, corner));
     corner = dummy->GetCornerPoint(true, false, false);
     CPPUNIT_ASSERT(mitk::Equal(refCorner, corner));
 
     // Corner 4
     mitk::FillVector3D(refCorner, bounds[1], bounds[2], bounds[4]);
     refCorner = anotherTransform->TransformPoint(refCorner);
     corner = dummy->GetCornerPoint(4);
     CPPUNIT_ASSERT(mitk::Equal(refCorner, corner));
     corner = dummy->GetCornerPoint(false, true, true);
     CPPUNIT_ASSERT(mitk::Equal(refCorner, corner));
 
     // Corner 5
     mitk::FillVector3D(refCorner, bounds[1], bounds[2], bounds[5]);
     refCorner = anotherTransform->TransformPoint(refCorner);
     corner = dummy->GetCornerPoint(5);
     CPPUNIT_ASSERT(mitk::Equal(refCorner, corner));
     corner = dummy->GetCornerPoint(false, true, false);
     CPPUNIT_ASSERT(mitk::Equal(refCorner, corner));
 
     // Corner 6
     mitk::FillVector3D(refCorner, bounds[1], bounds[3], bounds[4]);
     refCorner = anotherTransform->TransformPoint(refCorner);
     corner = dummy->GetCornerPoint(6);
     CPPUNIT_ASSERT(mitk::Equal(refCorner, corner));
     corner = dummy->GetCornerPoint(false, false, true);
     CPPUNIT_ASSERT(mitk::Equal(refCorner, corner));
 
     // Corner 7
     mitk::FillVector3D(refCorner, bounds[1], bounds[3], bounds[5]);
     refCorner = anotherTransform->TransformPoint(refCorner);
     corner = dummy->GetCornerPoint(7);
     CPPUNIT_ASSERT(mitk::Equal(refCorner, corner));
     corner = dummy->GetCornerPoint(false, false, false);
     CPPUNIT_ASSERT(mitk::Equal(refCorner, corner));
 
     // Wrong Corner needs to fail
     CPPUNIT_ASSERT_THROW(dummy->GetCornerPoint(20), itk::ExceptionObject);
 
     // dummy geometry must not have changed!
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     newDummy->SetIndexToWorldTransform(anotherTransform);
     newDummy->SetFloatBounds(bounds);
     MITK_ASSERT_EQUAL(dummy, newDummy, "Corner point");
   }
 
   void TestExtentInMM()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetExtentInMM(0, 50);
     CPPUNIT_ASSERT(mitk::Equal(50., dummy->GetExtentInMM(0)));
     // Vnl Matrix has changed. The next line only works because the spacing is 1!
     CPPUNIT_ASSERT(
       mitk::Equal(50., dummy->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0).magnitude()));
 
     // Smaller extent than original
     dummy->SetExtentInMM(0, 5);
     CPPUNIT_ASSERT(mitk::Equal(5., dummy->GetExtentInMM(0)));
     CPPUNIT_ASSERT(
       mitk::Equal(5., dummy->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(0).magnitude()));
 
     dummy->SetExtentInMM(1, 4);
     CPPUNIT_ASSERT(mitk::Equal(4., dummy->GetExtentInMM(1)));
     CPPUNIT_ASSERT(
       mitk::Equal(4., dummy->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(1).magnitude()));
 
     dummy->SetExtentInMM(2, 2.5);
     CPPUNIT_ASSERT(mitk::Equal(2.5, dummy->GetExtentInMM(2)));
     CPPUNIT_ASSERT(
       mitk::Equal(2.5, dummy->GetIndexToWorldTransform()->GetMatrix().GetVnlMatrix().get_column(2).magnitude()));
   }
 
   void TestGetAxisVector()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetIndexToWorldTransform(anotherTransform);
     double bounds[6] = {0, 11, 0, 12, 0, 13};
     dummy->SetFloatBounds(bounds);
 
     mitk::Vector3D vector;
     mitk::FillVector3D(vector, bounds[1], 0, 0);
     dummy->IndexToWorld(vector, vector);
     CPPUNIT_ASSERT(mitk::Equal(dummy->GetAxisVector(0), vector));
 
     mitk::FillVector3D(vector, 0, bounds[3], 0);
     dummy->IndexToWorld(vector, vector);
     CPPUNIT_ASSERT(mitk::Equal(dummy->GetAxisVector(1), vector));
 
     mitk::FillVector3D(vector, 0, 0, bounds[5]);
     dummy->IndexToWorld(vector, vector);
     CPPUNIT_ASSERT(mitk::Equal(dummy->GetAxisVector(2), vector));
   }
 
   void TestGetCenter()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetIndexToWorldTransform(anotherTransform);
     double bounds[6] = {0, 11, 2, 12, 1, 13};
     dummy->SetFloatBounds(bounds);
 
     mitk::Point3D refCenter;
     for (int i = 0; i < 3; i++)
       refCenter.SetElement(i, (bounds[2 * i] + bounds[2 * i + 1]) / 2.0);
 
     dummy->IndexToWorld(refCenter, refCenter);
 
     CPPUNIT_ASSERT(mitk::Equal(dummy->GetCenter(), refCenter));
   }
 
   void TestGetDiagonalLength()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     double bounds[6] = {1, 3, 5, 8, 7.5, 11.5};
     dummy->SetFloatBounds(bounds);
     // 3-1=2, 8-5=3, 11.5-7.5=4; 2^2+3^2+4^2 = 29
     double expectedLength = sqrt(29.);
 
     CPPUNIT_ASSERT(mitk::Equal(expectedLength, dummy->GetDiagonalLength(), mitk::eps, true));
     CPPUNIT_ASSERT(mitk::Equal(29., dummy->GetDiagonalLength2(), mitk::eps, true));
 
     // dummy must not have changed
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     newDummy->SetFloatBounds(bounds);
     MITK_ASSERT_EQUAL(dummy, newDummy, "Diagonal length");
   }
 
   void TestGetExtent()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     double bounds[6] = {1, 3, 5, 8, 7.5, 11.5};
     dummy->SetFloatBounds(bounds);
 
     CPPUNIT_ASSERT(mitk::Equal(2., dummy->GetExtent(0)));
     CPPUNIT_ASSERT(mitk::Equal(3., dummy->GetExtent(1)));
     CPPUNIT_ASSERT(mitk::Equal(4., dummy->GetExtent(2)));
 
     // dummy must not have changed
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     newDummy->SetFloatBounds(bounds);
     MITK_ASSERT_EQUAL(dummy, newDummy, "Extend");
   }
 
   void TestIsInside()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     double bounds[6] = {1, 3, 5, 8, 7.5, 11.5};
     dummy->SetFloatBounds(bounds);
 
     mitk::Point3D insidePoint;
     mitk::Point3D outsidePoint;
 
     mitk::FillVector3D(insidePoint, 2, 6, 7.6);
     mitk::FillVector3D(outsidePoint, 0, 9, 8.2);
 
     CPPUNIT_ASSERT(dummy->IsIndexInside(insidePoint));
     CPPUNIT_ASSERT(false == dummy->IsIndexInside(outsidePoint));
 
     dummy->IndexToWorld(insidePoint, insidePoint);
     dummy->IndexToWorld(outsidePoint, outsidePoint);
 
     CPPUNIT_ASSERT(dummy->IsInside(insidePoint));
     CPPUNIT_ASSERT(false == dummy->IsInside(outsidePoint));
 
     // dummy must not have changed
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     newDummy->SetFloatBounds(bounds);
     MITK_ASSERT_EQUAL(dummy, newDummy, "Is inside");
   }
 
   void TestInitialize()
   {
     // test standard constructor
     DummyTestClass::Pointer dummy1 = DummyTestClass::New();
 
     DummyTestClass::Pointer dummy2 = DummyTestClass::New();
     dummy2->SetOrigin(anotherPoint);
     dummy2->SetBounds(anotherBoundingBox->GetBounds());
     // mitk::TimeBounds timeBounds;
     // timeBounds[0] = 1;
     // timeBounds[1] = 9;
     // dummy2->SetTimeBounds(timeBounds);
     dummy2->SetIndexToWorldTransform(anotherTransform);
     dummy2->SetSpacing(anotherSpacing);
 
     dummy1->InitializeGeometry(dummy2);
 
     MITK_ASSERT_EQUAL(dummy1, dummy2, "Initialize 1");
 
     dummy1->Initialize();
 
     DummyTestClass::Pointer dummy3 = DummyTestClass::New();
     MITK_ASSERT_EQUAL(dummy3, dummy1, "Initialize 2");
   }
 
   void TestGetMatrixColumn()
   {
     DummyTestClass::Pointer dummy = DummyTestClass::New();
     dummy->SetIndexToWorldTransform(anotherTransform);
     mitk::Vector3D testVector, refVector;
 
     testVector.SetVnlVector(dummy->GetMatrixColumn(0));
     mitk::FillVector3D(refVector, 1, 0, 0);
     CPPUNIT_ASSERT(testVector == refVector);
 
     testVector.SetVnlVector(dummy->GetMatrixColumn(1));
     mitk::FillVector3D(refVector, 0, 2, 0);
     CPPUNIT_ASSERT(testVector == refVector);
 
     testVector.SetVnlVector(dummy->GetMatrixColumn(2));
     mitk::FillVector3D(refVector, 0, 0, 1);
     CPPUNIT_ASSERT(testVector == refVector);
 
     // dummy must not have changed
     DummyTestClass::Pointer newDummy = DummyTestClass::New();
     newDummy->SetIndexToWorldTransform(anotherTransform);
     MITK_ASSERT_EQUAL(dummy, newDummy, "GetMatrixColumn");
   }
 
+  void IsSubGeometry_Spacing()
+  {
+    CPPUNIT_ASSERT(mitk::IsSubGeometry(*aDummyGeometry, *aDummyGeometry, mitk::eps, true));
+
+    for (unsigned int i = 0; i < 3; ++i)
+    {
+      mitk::Vector3D wrongSpacing = aDummyGeometry->GetSpacing();
+      wrongSpacing[i] += mitk::eps * 2;
+      auto wrongGeometry = aDummyGeometry->Clone();
+      wrongGeometry->SetSpacing(wrongSpacing);
+
+      CPPUNIT_ASSERT(!mitk::IsSubGeometry(*wrongGeometry, *aDummyGeometry, mitk::eps, true));
+    }
+    for (unsigned int i = 0; i < 3; ++i)
+    {
+      mitk::Vector3D wrongSpacing = aDummyGeometry->GetSpacing();
+      wrongSpacing[i] -= mitk::eps * 2;
+      auto wrongGeometry = aDummyGeometry->Clone();
+      wrongGeometry->SetSpacing(wrongSpacing);
+
+      CPPUNIT_ASSERT(!mitk::IsSubGeometry(*wrongGeometry, *aDummyGeometry, mitk::eps, true));
+    }
+  }
+
+  void IsSubGeometry_TransformMatrix()
+  {
+    CPPUNIT_ASSERT(mitk::IsSubGeometry(*aDummyGeometry, *aDummyGeometry, mitk::eps, true));
+
+    for (unsigned int i = 0; i < 3; ++i)
+    {
+      for (unsigned int j = 0; j < 3; ++j)
+      {
+        itk::Matrix<mitk::ScalarType, 3, 3> wrongMatrix = aDummyGeometry->GetIndexToWorldTransform()->GetMatrix();
+        wrongMatrix[i][j] += mitk::eps * 2;
+        auto wrongGeometry = aDummyGeometry->Clone();
+        wrongGeometry->GetIndexToWorldTransform()->SetMatrix(wrongMatrix);
+
+        CPPUNIT_ASSERT(!mitk::IsSubGeometry(*wrongGeometry, *aDummyGeometry, mitk::eps, true));
+      }
+    }
+  }
+
+  void IsSubGeometry_Bounds()
+  {
+    IsSubGeometry_Bounds_internal(false);
+    IsSubGeometry_Bounds_internal(true);
+  }
+
+  void IsSubGeometry_Bounds_internal(bool isImage)
+  {
+    auto newBounds = aDummyGeometry->GetBounds();
+    newBounds[0] = 10;
+    newBounds[1] = 20;
+    newBounds[2] = 10;
+    newBounds[3] = 20;
+    newBounds[4] = 10;
+    newBounds[5] = 20;
+    aDummyGeometry->SetBounds(newBounds);
+    aDummyGeometry->SetImageGeometry(isImage);
+
+    CPPUNIT_ASSERT(mitk::IsSubGeometry(*aDummyGeometry, *aDummyGeometry, mitk::eps, true));
+
+    for (unsigned int i = 0; i < 6; ++i)
+    {
+      auto legalBounds = newBounds;
+      if (i % 2 == 0)
+      {
+        legalBounds[i] += 1;
+      }
+      else
+      {
+        legalBounds[i] -= 1;
+      }
+      auto legalGeometry = aDummyGeometry->Clone();
+      legalGeometry->SetBounds(legalBounds);
+
+      CPPUNIT_ASSERT(mitk::IsSubGeometry(*legalGeometry, *aDummyGeometry, mitk::eps, true));
+    }
+
+    for (unsigned int i = 0; i < 6; ++i)
+    {
+      auto wrongBounds = aDummyGeometry->GetBounds();
+      if (i % 2 == 0)
+      {
+        wrongBounds[i] -= 1;
+      }
+      else
+      {
+        wrongBounds[i] += 1;
+      }
+      auto wrongGeometry = aDummyGeometry->Clone();
+      wrongGeometry->SetBounds(wrongBounds);
+
+      CPPUNIT_ASSERT(!mitk::IsSubGeometry(*wrongGeometry, *aDummyGeometry, mitk::eps, true));
+    }
+  }
+
+  void IsSubGeometry_Grid()
+  {
+    IsSubGeometry_Grid_internal(true);
+    IsSubGeometry_Grid_internal(false);
+  }
+
+  void IsSubGeometry_Grid_internal(bool isImage)
+  {
+    auto newBounds = aDummyGeometry->GetBounds();
+    newBounds[0] = 0;
+    newBounds[1] = 20;
+    newBounds[2] = 0;
+    newBounds[3] = 20;
+    newBounds[4] = 0;
+    newBounds[5] = 20;
+    aDummyGeometry->SetBounds(newBounds);
+    aDummyGeometry->SetImageGeometry(isImage);
+
+    auto smallerGeometry = aDummyGeometry->Clone();
+    newBounds[0] = 5;
+    newBounds[1] = 10;
+    newBounds[2] = 5;
+    newBounds[3] = 10;
+    newBounds[4] = 5;
+    newBounds[5] = 10;
+    smallerGeometry->SetBounds(newBounds);
+
+    //legal negative shift
+    for (unsigned int i = 0; i < 3; ++i)
+    {
+      auto legalOrigin = smallerGeometry->GetOrigin();
+      legalOrigin[i] -= smallerGeometry->GetSpacing()[i];
+      auto legalGeometry = smallerGeometry->Clone();
+      legalGeometry->SetOrigin(legalOrigin);
+
+      CPPUNIT_ASSERT(mitk::IsSubGeometry(*legalGeometry, *aDummyGeometry, mitk::eps, true));
+    }
+
+    //legal positive shift
+    for (unsigned int i = 0; i < 3; ++i)
+    {
+      auto legalOrigin = smallerGeometry->GetOrigin();
+      legalOrigin[i] += smallerGeometry->GetSpacing()[i];
+      auto legalGeometry = smallerGeometry->Clone();
+      legalGeometry->SetOrigin(legalOrigin);
+
+      CPPUNIT_ASSERT(mitk::IsSubGeometry(*legalGeometry, *aDummyGeometry, mitk::eps, true));
+    }
+
+    //wrong negative shift
+    for (unsigned int i = 0; i < 3; ++i)
+    {
+      auto wrongOrigin = smallerGeometry->GetOrigin();
+      wrongOrigin[i] -= 2 * mitk::eps;
+      auto wrongGeometry = smallerGeometry->Clone();
+      wrongGeometry->SetOrigin(wrongOrigin);
+
+      CPPUNIT_ASSERT(!mitk::IsSubGeometry(*wrongGeometry, *aDummyGeometry, mitk::eps, true));
+    }
+
+    //wrong positive shift
+    for (unsigned int i = 0; i < 3; ++i)
+    {
+      auto wrongOrigin = smallerGeometry->GetOrigin();
+      wrongOrigin[i] += 2 * mitk::eps;
+      auto wrongGeometry = smallerGeometry->Clone();
+      wrongGeometry->SetOrigin(wrongOrigin);
+
+      CPPUNIT_ASSERT(!mitk::IsSubGeometry(*wrongGeometry, *aDummyGeometry, mitk::eps, true));
+    }
+  }
+
+
   /*
 
   void (){
   DummyTestClass::Pointer dummy = DummyTestClass::New();
 
   CPPUNIT_ASSERT();
 
   //undo changes, new and changed object need to be the same!
 
   DummyTestClass::Pointer newDummy = DummyTestClass::New();
   CPPUNIT_ASSERT(mitk::Equal(dummy,newDummy,mitk::eps,true));
   }
 
   */
 }; // end class mitkBaseGeometryTestSuite
 
 MITK_TEST_SUITE_REGISTRATION(mitkBaseGeometry)
diff --git a/Modules/Core/test/mitkNodePredicateSubGeometryTest.cpp b/Modules/Core/test/mitkNodePredicateSubGeometryTest.cpp
new file mode 100644
index 0000000000..e931e20e27
--- /dev/null
+++ b/Modules/Core/test/mitkNodePredicateSubGeometryTest.cpp
@@ -0,0 +1,243 @@
+/*============================================================================
+
+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 "mitkGeometry3D.h"
+#include "mitkBaseDataTestImplementation.h"
+#include "mitkNodePredicateSubGeometry.h"
+#include "mitkDataNode.h"
+#include "mitkTestFixture.h"
+#include "mitkTestingMacros.h"
+
+class mitkNodePredicateSubGeometryTestSuite : public mitk::TestFixture
+{
+  CPPUNIT_TEST_SUITE(mitkNodePredicateSubGeometryTestSuite);
+  MITK_TEST(Check_InvalidConstructor);
+  MITK_TEST(Check_Spacing);
+  MITK_TEST(Check_TransformMatrix);
+  MITK_TEST(Check_Bounds);
+  MITK_TEST(Check_Grid);
+  CPPUNIT_TEST_SUITE_END();
+
+private:
+  mitk::BaseDataTestImplementation::Pointer m_Data;
+  mitk::DataNode::Pointer m_Node;
+
+  mitk::Geometry3D::Pointer m_RefGeometry;
+
+  mitk::Geometry3D::Pointer m_AnotherGeometry3D;
+
+public:
+  /**
+* @brief Setup Always call this method before each Test-case to ensure correct and new intialization of the used members
+* for a new test case. (If the members are not used in a test, the method does not need to be called).
+*/
+  void setUp() override
+  {
+    m_RefGeometry = mitk::Geometry3D::New();
+    m_RefGeometry->Initialize();
+
+    m_Data = mitk::BaseDataTestImplementation::New();
+    m_Data->SetClonedGeometry(m_RefGeometry);
+
+    m_Node = mitk::DataNode::New();
+    m_Node->SetData(m_Data);
+
+    m_AnotherGeometry3D = m_RefGeometry->Clone();
+  }
+
+  void tearDown() override
+  {
+    m_RefGeometry = nullptr;
+    m_AnotherGeometry3D = nullptr;
+    m_Data = nullptr;
+  }
+
+  void Check_InvalidConstructor()
+  {
+    m_RefGeometry = nullptr;
+    CPPUNIT_ASSERT_THROW(mitk::NodePredicateSubGeometry::New(m_RefGeometry, 3), mitk::Exception);
+    CPPUNIT_ASSERT_THROW(mitk::NodePredicateSubGeometry::New(m_RefGeometry), mitk::Exception);
+  }
+
+  void Check_CloneAndOriginal()
+  {
+    mitk::NodePredicateSubGeometry::Pointer predicate = mitk::NodePredicateSubGeometry::New(m_RefGeometry);
+
+    CPPUNIT_ASSERT(predicate->CheckNode(m_Node));
+  }
+
+  void Check_Spacing()
+  {
+    mitk::NodePredicateSubGeometry::Pointer predicate = mitk::NodePredicateSubGeometry::New(m_RefGeometry);
+
+    for (unsigned int i = 0; i < 3; ++i)
+    {
+      mitk::Vector3D wrongSpacing = m_RefGeometry->GetSpacing();
+      wrongSpacing[i] += mitk::eps * 2;
+      auto wrongGeometry = m_RefGeometry->Clone();
+      wrongGeometry->SetSpacing(wrongSpacing);
+      m_Node->GetData()->SetGeometry(wrongGeometry);
+
+      CPPUNIT_ASSERT(!predicate->CheckNode(m_Node));
+    }
+    for (unsigned int i = 0; i < 3; ++i)
+    {
+      mitk::Vector3D wrongSpacing = m_RefGeometry->GetSpacing();
+      wrongSpacing[i] -= mitk::eps * 2;
+      auto wrongGeometry = m_RefGeometry->Clone();
+      wrongGeometry->SetSpacing(wrongSpacing);
+      m_Node->GetData()->SetGeometry(wrongGeometry);
+
+      CPPUNIT_ASSERT(!predicate->CheckNode(m_Node));
+    }
+  }
+
+  void Check_TransformMatrix()
+  {
+    mitk::NodePredicateSubGeometry::Pointer predicate = mitk::NodePredicateSubGeometry::New(m_RefGeometry);
+
+    for (unsigned int i = 0; i < 3; ++i)
+    {
+      for (unsigned int j = 0; j < 3; ++j)
+      {
+        itk::Matrix<mitk::ScalarType, 3, 3> wrongMatrix = m_RefGeometry->GetIndexToWorldTransform()->GetMatrix();
+        wrongMatrix[i][j] += mitk::eps * 2;
+        auto wrongGeometry = m_RefGeometry->Clone();
+        wrongGeometry->GetIndexToWorldTransform()->SetMatrix(wrongMatrix);
+        m_Node->GetData()->SetGeometry(wrongGeometry);
+
+        CPPUNIT_ASSERT(!predicate->CheckNode(m_Node));
+      }
+    }
+  }
+
+  void Check_Bounds()
+  {
+    auto newBounds = m_RefGeometry->GetBounds();
+    newBounds[0] = 10;
+    newBounds[1] = 20;
+    newBounds[2] = 10;
+    newBounds[3] = 20;
+    newBounds[4] = 10;
+    newBounds[5] = 20;
+    m_RefGeometry->SetBounds(newBounds);
+    mitk::NodePredicateSubGeometry::Pointer predicate = mitk::NodePredicateSubGeometry::New(m_RefGeometry);
+
+    for (unsigned int i = 0; i < 6; ++i)
+    {
+      auto legalBounds = newBounds;
+      if (i % 2 == 0)
+      {
+        legalBounds[i] += 1;
+      }
+      else
+      {
+        legalBounds[i] -= 1;
+      }
+      auto legalGeometry = m_RefGeometry->Clone();
+      legalGeometry->SetBounds(legalBounds);
+      m_Node->GetData()->SetGeometry(legalGeometry);
+
+      CPPUNIT_ASSERT(predicate->CheckNode(m_Node));
+    }
+
+    for (unsigned int i = 0; i < 6; ++i)
+    {
+      auto wrongBounds = m_RefGeometry->GetBounds();
+      if (i % 2 == 0)
+      {
+        wrongBounds[i] -= 1;
+      }
+      else
+      {
+        wrongBounds[i] += 1;
+      }
+      auto wrongGeometry = m_RefGeometry->Clone();
+      wrongGeometry->SetBounds(wrongBounds);
+      m_Node->GetData()->SetGeometry(wrongGeometry);
+
+      CPPUNIT_ASSERT(!predicate->CheckNode(m_Node));
+    }
+  }
+
+  void Check_Grid()
+  {
+    auto newBounds = m_RefGeometry->GetBounds();
+    newBounds[0] = 0;
+    newBounds[1] = 20;
+    newBounds[2] = 0;
+    newBounds[3] = 20;
+    newBounds[4] = 0;
+    newBounds[5] = 20;
+    m_RefGeometry->SetBounds(newBounds);
+    mitk::NodePredicateSubGeometry::Pointer predicate = mitk::NodePredicateSubGeometry::New(m_RefGeometry);
+
+    auto smallerGeometry = m_RefGeometry->Clone();
+    newBounds[0] = 5;
+    newBounds[1] = 10;
+    newBounds[2] = 5;
+    newBounds[3] = 10;
+    newBounds[4] = 5;
+    newBounds[5] = 10;
+    smallerGeometry->SetBounds(newBounds);
+
+    //legal negative shift
+    for (unsigned int i = 0; i < 3; ++i)
+    {
+      auto legalOrigin = smallerGeometry->GetOrigin();
+      legalOrigin[i] -= smallerGeometry->GetSpacing()[i];
+      auto legalGeometry = smallerGeometry->Clone();
+      legalGeometry->SetOrigin(legalOrigin);
+      m_Node->GetData()->SetGeometry(legalGeometry);
+
+      CPPUNIT_ASSERT(predicate->CheckNode(m_Node));
+    }
+
+    //legal positive shift
+    for (unsigned int i = 0; i < 3; ++i)
+    {
+      auto legalOrigin = smallerGeometry->GetOrigin();
+      legalOrigin[i] += smallerGeometry->GetSpacing()[i];
+      auto legalGeometry = smallerGeometry->Clone();
+      legalGeometry->SetOrigin(legalOrigin);
+      m_Node->GetData()->SetGeometry(legalGeometry);
+
+      CPPUNIT_ASSERT(predicate->CheckNode(m_Node));
+    }
+
+    //wrong negative shift
+    for (unsigned int i = 0; i < 3; ++i)
+    {
+      auto wrongOrigin = smallerGeometry->GetOrigin();
+      wrongOrigin[i] -= 2 * mitk::eps;
+      auto wrongGeometry = smallerGeometry->Clone();
+      wrongGeometry->SetOrigin(wrongOrigin);
+      m_Node->GetData()->SetGeometry(wrongGeometry);
+
+      CPPUNIT_ASSERT(!predicate->CheckNode(m_Node));
+    }
+
+    //wrong positive shift
+    for (unsigned int i = 0; i < 3; ++i)
+    {
+      auto wrongOrigin = smallerGeometry->GetOrigin();
+      wrongOrigin[i] += 2 * mitk::eps;
+      auto wrongGeometry = smallerGeometry->Clone();
+      wrongGeometry->SetOrigin(wrongOrigin);
+      m_Node->GetData()->SetGeometry(wrongGeometry);
+
+      CPPUNIT_ASSERT(!predicate->CheckNode(m_Node));
+    }
+  }
+};
+
+MITK_TEST_SUITE_REGISTRATION(mitkNodePredicateSubGeometry)
diff --git a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
index b162805d3a..be6c8c3bdb 100644
--- a/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
+++ b/Plugins/org.mitk.gui.qt.measurementtoolbox/src/internal/QmitkImageStatisticsView.cpp
@@ -1,435 +1,442 @@
 /*============================================================================
 
 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 "QmitkImageStatisticsView.h"
 
 #include <utility>
 
 // berry includes
 #include <berryIQtStyleManager.h>
 #include <berryWorkbenchPlugin.h>
 
 #include <QmitkChartWidget.h>
 #include <mitkImageStatisticsContainerNodeHelper.h>
 #include <mitkImageStatisticsPredicateHelper.h>
 #include <mitkImageTimeSelector.h>
 #include <mitkIntensityProfile.h>
 #include <mitkNodePredicateAnd.h>
 #include <mitkNodePredicateGeometry.h>
+#include <mitkNodePredicateSubGeometry.h>
 #include <mitkNodePredicateOr.h>
 #include <mitkNodePredicateFunction.h>
 #include <mitkSliceNavigationController.h>
 #include <mitkStatusBar.h>
 #include <mitkPlanarFigure.h>
 #include "mitkPlanarFigureMaskGenerator.h"
 
 #include "QmitkImageStatisticsDataGenerator.h"
 
 #include "mitkImageStatisticsContainerManager.h"
 #include <mitkPlanarFigureInteractor.h>
 
 const std::string QmitkImageStatisticsView::VIEW_ID = "org.mitk.views.imagestatistics";
 
 QmitkImageStatisticsView::~QmitkImageStatisticsView()
 {
 }
 
 void QmitkImageStatisticsView::CreateQtPartControl(QWidget *parent)
 {
   m_Controls.setupUi(parent);
   m_Controls.widget_histogram->SetTheme(GetColorTheme());
   m_Controls.widget_intensityProfile->SetTheme(GetColorTheme());
   m_Controls.groupBox_histogram->setVisible(true);
   m_Controls.groupBox_intensityProfile->setVisible(false);
   m_Controls.label_currentlyComputingStatistics->setVisible(false);
   m_Controls.sliderWidget_histogram->setPrefix("Time: ");
   m_Controls.sliderWidget_histogram->setDecimals(0);
   m_Controls.sliderWidget_histogram->setVisible(false);
   m_Controls.sliderWidget_intensityProfile->setPrefix("Time: ");
   m_Controls.sliderWidget_intensityProfile->setDecimals(0);
   m_Controls.sliderWidget_intensityProfile->setVisible(false);
   ResetGUI();
 
   m_DataGenerator = new QmitkImageStatisticsDataGenerator(parent);
   m_DataGenerator->SetDataStorage(this->GetDataStorage());
   m_DataGenerator->SetAutoUpdate(true);
   m_Controls.widget_statistics->SetDataStorage(this->GetDataStorage());
   m_Controls.widget_histogram->SetTheme(GetColorTheme());
 
   m_Controls.imageNodesSelector->SetDataStorage(this->GetDataStorage());
   m_Controls.imageNodesSelector->SetNodePredicate(mitk::GetImageStatisticsImagePredicate());
   m_Controls.imageNodesSelector->SetSelectionCheckFunction(this->CheckForSameGeometry());
   m_Controls.imageNodesSelector->SetSelectionIsOptional(false);
   m_Controls.imageNodesSelector->SetInvalidInfo(QStringLiteral("Please select images for statistics"));
   m_Controls.imageNodesSelector->SetPopUpTitel(QStringLiteral("Select input images"));
   m_Controls.roiNodesSelector->SetPopUpHint(QStringLiteral("You may select multiple images for the statistics computation. But all selected images must have the same geometry."));
 
   m_Controls.roiNodesSelector->SetDataStorage(this->GetDataStorage());
   m_Controls.roiNodesSelector->SetNodePredicate(this->GenerateROIPredicate());
   m_Controls.roiNodesSelector->SetSelectionIsOptional(true);
   m_Controls.roiNodesSelector->SetEmptyInfo(QStringLiteral("Please select ROIs"));
   m_Controls.roiNodesSelector->SetPopUpTitel(QStringLiteral("Select ROIs for statistics computation"));
   m_Controls.roiNodesSelector->SetPopUpHint(QStringLiteral("You may select ROIs (e.g. planar figures, segmentations) that should be used for the statistics computation. The statistics will only computed for the image parts defined by the ROIs."));
 
 
   CreateConnections();
 }
 
 void QmitkImageStatisticsView::CreateConnections()
 {
   connect(m_Controls.checkBox_ignoreZero, &QCheckBox::stateChanged,
     this, &QmitkImageStatisticsView::OnCheckBoxIgnoreZeroStateChanged);
   connect(m_Controls.buttonSelection, &QAbstractButton::clicked,
     this, &QmitkImageStatisticsView::OnButtonSelectionPressed);
 
   connect(m_Controls.widget_histogram, &QmitkHistogramVisualizationWidget::RequestHistogramUpdate,
     this, &QmitkImageStatisticsView::OnRequestHistogramUpdate);
 
   connect(m_DataGenerator, &QmitkImageStatisticsDataGenerator::DataGenerationStarted,
     this, &QmitkImageStatisticsView::OnGenerationStarted);
   connect(m_DataGenerator, &QmitkImageStatisticsDataGenerator::GenerationFinished,
     this, &QmitkImageStatisticsView::OnGenerationFinished);
   connect(m_DataGenerator, &QmitkImageStatisticsDataGenerator::JobError,
     this, &QmitkImageStatisticsView::OnJobError);
 
   connect(m_Controls.imageNodesSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
     this, &QmitkImageStatisticsView::OnImageSelectionChanged);
   connect(m_Controls.roiNodesSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
     this, &QmitkImageStatisticsView::OnROISelectionChanged);
 }
 
 void QmitkImageStatisticsView::UpdateIntensityProfile()
 {
   m_Controls.groupBox_intensityProfile->setVisible(false);
 
   const auto selectedImageNodes = m_Controls.imageNodesSelector->GetSelectedNodes();
   const auto selectedROINodes = m_Controls.roiNodesSelector->GetSelectedNodes();
 
   if (selectedImageNodes.size()==1 && selectedROINodes.size()==1)
   { //only supported for one image and roi currently
     auto image = dynamic_cast<mitk::Image*>(selectedImageNodes.front()->GetData());
 
     auto maskPlanarFigure = dynamic_cast<mitk::PlanarFigure*>(selectedROINodes.front()->GetData());
 
     if (maskPlanarFigure != nullptr)
     {
       if (!maskPlanarFigure->IsClosed())
       {
         mitk::Image::Pointer inputImage;
         if (image->GetDimension() == 4)
         {
           m_Controls.sliderWidget_intensityProfile->setVisible(true);
           unsigned int maxTimestep = image->GetTimeSteps();
           m_Controls.sliderWidget_intensityProfile->setMaximum(maxTimestep - 1);
           // Intensity profile can only be calculated on 3D, so extract if 4D
           mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New();
           int currentTimestep = static_cast<int>(m_Controls.sliderWidget_intensityProfile->value());
           timeSelector->SetInput(image);
           timeSelector->SetTimeNr(currentTimestep);
           timeSelector->Update();
 
           inputImage = timeSelector->GetOutput();
         }
         else
         {
           m_Controls.sliderWidget_intensityProfile->setVisible(false);
           inputImage = image;
         }
 
         auto intensityProfile = mitk::ComputeIntensityProfile(inputImage, maskPlanarFigure);
         m_Controls.groupBox_intensityProfile->setVisible(true);
         m_Controls.widget_intensityProfile->Reset();
         m_Controls.widget_intensityProfile->SetIntensityProfile(intensityProfile.GetPointer(),
           "Intensity Profile of " + selectedImageNodes.front()->GetName());
       }
     }
   }
 }
 
 void QmitkImageStatisticsView::UpdateHistogramWidget()
 {
   m_Controls.groupBox_histogram->setVisible(false);
 
   const auto selectedImageNodes = m_Controls.imageNodesSelector->GetSelectedNodes();
   const auto selectedMaskNodes = m_Controls.roiNodesSelector->GetSelectedNodes();
 
   if (selectedImageNodes.size() == 1 && selectedMaskNodes.size()<=1)
   { //currently only supported for one image and roi due to histogram widget limitations.
     auto imageNode = selectedImageNodes.front();
     const mitk::DataNode* roiNode = nullptr;
     const mitk::PlanarFigure* planarFigure = nullptr;
     if (!selectedMaskNodes.empty())
     {
       roiNode = selectedMaskNodes.front();
       planarFigure = dynamic_cast<const mitk::PlanarFigure*>(roiNode->GetData());
     }
 
     if (planarFigure == nullptr || planarFigure->IsClosed())
     { //if a planar figure is not closed, we show the intensity profile instead of the histogram.
       auto statisticsNode = m_DataGenerator->GetLatestResult(imageNode, roiNode, true);
 
       if (statisticsNode.IsNotNull())
       {
         auto statistics = dynamic_cast<const mitk::ImageStatisticsContainer*>(statisticsNode->GetData());
 
         if (statistics)
         {
           std::stringstream label;
           label << "Histogram " << imageNode->GetName();
           if (imageNode->GetData()->GetTimeSteps() > 1)
           {
             label << "[0]";
           }
 
           if (roiNode)
           {
             label << " with " << roiNode->GetName();
           }
 
           m_Controls.widget_histogram->SetHistogram(statistics->GetHistogramForTimeStep(0), label.str());
         }
         m_Controls.groupBox_histogram->setVisible(statisticsNode.IsNotNull());
       }
     }
   }
 }
 
 QmitkChartWidget::ColorTheme QmitkImageStatisticsView::GetColorTheme() const
 {
   ctkPluginContext *context = berry::WorkbenchPlugin::GetDefault()->GetPluginContext();
   ctkServiceReference styleManagerRef = context->getServiceReference<berry::IQtStyleManager>();
   if (styleManagerRef)
   {
     auto styleManager = context->getService<berry::IQtStyleManager>(styleManagerRef);
     if (styleManager->GetStyle().name == "Dark")
     {
       return QmitkChartWidget::ColorTheme::darkstyle;
     }
     else
     {
       return QmitkChartWidget::ColorTheme::lightstyle;
     }
   }
   return QmitkChartWidget::ColorTheme::darkstyle;
 }
 
 void QmitkImageStatisticsView::ResetGUI()
 {
   m_Controls.widget_statistics->Reset();
   m_Controls.widget_statistics->setEnabled(false);
   m_Controls.widget_histogram->Reset();
   m_Controls.widget_histogram->setEnabled(false);
   m_Controls.widget_histogram->SetTheme(GetColorTheme());
 }
 
 void QmitkImageStatisticsView::OnGenerationStarted(const mitk::DataNode* /*imageNode*/, const mitk::DataNode* /*roiNode*/, const QmitkDataGenerationJobBase* /*job*/)
 {
   m_Controls.label_currentlyComputingStatistics->setVisible(true);
 }
 
 void QmitkImageStatisticsView::OnGenerationFinished()
 {
   m_Controls.label_currentlyComputingStatistics->setVisible(false);
 
   mitk::StatusBar::GetInstance()->Clear();
 
   this->UpdateIntensityProfile();
   this->UpdateHistogramWidget();
 }
 
 void QmitkImageStatisticsView::OnJobError(QString error, const QmitkDataGenerationJobBase* /*failedJob*/)
 {
   mitk::StatusBar::GetInstance()->DisplayErrorText(error.toStdString().c_str());
   MITK_WARN << "Error when calculating statistics: " << error;
 }
 
 void QmitkImageStatisticsView::OnRequestHistogramUpdate(unsigned int nbins)
 {
   m_Controls.widget_statistics->SetHistogramNBins(nbins);
   m_DataGenerator->SetHistogramNBins(nbins);
   this->UpdateIntensityProfile();
   this->UpdateHistogramWidget();
 }
 
 void QmitkImageStatisticsView::OnCheckBoxIgnoreZeroStateChanged(int state)
 {
   auto ignoreZeroValueVoxel = (state == Qt::Unchecked) ? false : true;
   m_Controls.widget_statistics->SetIgnoreZeroValueVoxel(ignoreZeroValueVoxel);
   m_DataGenerator->SetIgnoreZeroValueVoxel(ignoreZeroValueVoxel);
   this->UpdateIntensityProfile();
   this->UpdateHistogramWidget();
 }
 
 void QmitkImageStatisticsView::OnImageSelectionChanged(QmitkAbstractNodeSelectionWidget::NodeList /*nodes*/)
 {
   auto images = m_Controls.imageNodesSelector->GetSelectedNodesStdVector();
   m_Controls.widget_statistics->SetImageNodes(images);
 
+  m_Controls.widget_statistics->setEnabled(!images.empty());
+
+  m_Controls.roiNodesSelector->SetNodePredicate(this->GenerateROIPredicate());
+
   m_DataGenerator->SetAutoUpdate(false);
   m_DataGenerator->SetImageNodes(images);
   m_DataGenerator->Generate();
   m_DataGenerator->SetAutoUpdate(true);
 
-  m_Controls.widget_statistics->setEnabled(!images.empty());
-
-  m_Controls.roiNodesSelector->SetNodePredicate(this->GenerateROIPredicate());
-
   this->UpdateHistogramWidget();
   this->UpdateIntensityProfile();
 }
 
 void QmitkImageStatisticsView::OnROISelectionChanged(QmitkAbstractNodeSelectionWidget::NodeList /*nodes*/)
 {
   auto rois = m_Controls.roiNodesSelector->GetSelectedNodesStdVector();
 
   m_Controls.widget_statistics->SetMaskNodes(rois);
 
   m_DataGenerator->SetAutoUpdate(false);
   m_DataGenerator->SetROINodes(rois);
   m_DataGenerator->Generate();
   m_DataGenerator->SetAutoUpdate(true);
 
   this->UpdateHistogramWidget();
   this->UpdateIntensityProfile();
 }
 
 
 void QmitkImageStatisticsView::OnButtonSelectionPressed()
 {
   QmitkNodeSelectionDialog* dialog = new QmitkNodeSelectionDialog(nullptr, "Select input for the statistic","You may select images and ROIs to compute their statistic. ROIs may be segmentations or planar figures.");
   dialog->SetDataStorage(GetDataStorage());
   dialog->SetSelectionCheckFunction(CheckForSameGeometry());
 
   // set predicates
   auto isPlanarFigurePredicate = mitk::GetImageStatisticsPlanarFigurePredicate();
   auto isMaskPredicate = mitk::GetImageStatisticsMaskPredicate();
   auto isImagePredicate = mitk::GetImageStatisticsImagePredicate();
   auto isMaskOrPlanarFigurePredicate = mitk::NodePredicateOr::New(isPlanarFigurePredicate, isMaskPredicate);
   auto isImageOrMaskOrPlanarFigurePredicate = mitk::NodePredicateOr::New(isMaskOrPlanarFigurePredicate, isImagePredicate);
   dialog->SetNodePredicate(isImageOrMaskOrPlanarFigurePredicate);
   dialog->SetSelectionMode(QAbstractItemView::MultiSelection);
   dialog->SetCurrentSelection(m_Controls.imageNodesSelector->GetSelectedNodes()+m_Controls.roiNodesSelector->GetSelectedNodes());
 
   if (dialog->exec())
   {
     auto selectedNodeList = dialog->GetSelectedNodes();
 
     m_Controls.imageNodesSelector->SetCurrentSelection(selectedNodeList);
     m_Controls.roiNodesSelector->SetCurrentSelection(selectedNodeList);
   }
 
   delete dialog;
 }
 
 QmitkNodeSelectionDialog::SelectionCheckFunctionType QmitkImageStatisticsView::CheckForSameGeometry() const
 {
-  auto lambda = [](const QmitkNodeSelectionDialog::NodeList& nodes)
+  auto isMaskPredicate = mitk::GetImageStatisticsMaskPredicate();
+
+  auto lambda = [isMaskPredicate](const QmitkNodeSelectionDialog::NodeList& nodes)
   {
     if (nodes.empty())
     {
       return std::string();
     }
 
     const mitk::Image* imageNodeData = nullptr;
-
     for (auto& node : nodes)
     {
-      imageNodeData = dynamic_cast<const mitk::Image*>(node->GetData());
-      if (imageNodeData)
+      auto castedData = dynamic_cast<const mitk::Image*>(node->GetData());
+      if (castedData != nullptr && !isMaskPredicate->CheckNode(node))
       {
+        imageNodeData = castedData;
         break;
       }
     }
 
     if (imageNodeData == nullptr)
     {
       std::stringstream ss;
       ss << "<font class=\"warning\"><p>Select at least one image.</p></font>";
       return ss.str();
     }
 
     auto imageGeoPredicate = mitk::NodePredicateGeometry::New(imageNodeData->GetGeometry());
+    auto maskGeoPredicate = mitk::NodePredicateSubGeometry::New(imageNodeData->GetGeometry());
 
     for (auto& rightNode : nodes)
     {
       if (imageNodeData != rightNode->GetData())
       {
-        bool sameGeometry = true;
+        bool validGeometry = true;
 
-        if (dynamic_cast<const mitk::Image*>(rightNode->GetData()))
+        if (isMaskPredicate->CheckNode(rightNode))
         {
-          sameGeometry = imageGeoPredicate->CheckNode(rightNode);
+          validGeometry = maskGeoPredicate->CheckNode(rightNode);
+        }
+        else if (dynamic_cast<const mitk::Image*>(rightNode->GetData()))
+        {
+          validGeometry = imageGeoPredicate->CheckNode(rightNode);
         }
         else
         {
           const mitk::PlanarFigure* planar2 = dynamic_cast<const mitk::PlanarFigure*>(rightNode->GetData());
           if (planar2)
           {
-            sameGeometry = mitk::PlanarFigureMaskGenerator::CheckPlanarFigureIsNotTilted(planar2->GetPlaneGeometry(), imageNodeData->GetGeometry());
+            validGeometry = mitk::PlanarFigureMaskGenerator::CheckPlanarFigureIsNotTilted(planar2->GetPlaneGeometry(), imageNodeData->GetGeometry());
           }
         }
 
-        if (!sameGeometry)
+        if (!validGeometry)
         {
           std::stringstream ss;
           ss << "<font class=\"warning\"><p>Invalid selection: All selected nodes must have the same geometry.</p><p>Differing node i.a.: \"";
           ss << rightNode->GetName() <<"\"</p></font>";
           return ss.str();
         }
       }
     }
 
     return std::string();
   };
 
   return lambda;
 }
 
 mitk::NodePredicateBase::Pointer QmitkImageStatisticsView::GenerateROIPredicate() const
 {
   auto isPlanarFigurePredicate = mitk::GetImageStatisticsPlanarFigurePredicate();
   auto isMaskPredicate = mitk::GetImageStatisticsMaskPredicate();
   auto isMaskOrPlanarFigurePredicate = mitk::NodePredicateOr::New(isPlanarFigurePredicate, isMaskPredicate);
 
   mitk::NodePredicateBase::Pointer result = isMaskOrPlanarFigurePredicate.GetPointer();
 
   if(!m_Controls.imageNodesSelector->GetSelectedNodes().empty())
   {
     auto image = m_Controls.imageNodesSelector->GetSelectedNodes().front()->GetData();
+    auto imageGeoPredicate = mitk::NodePredicateSubGeometry::New(image->GetGeometry());
 
-    auto lambda = [image](const mitk::DataNode* node)
+    auto lambda = [image, imageGeoPredicate](const mitk::DataNode* node)
     {
-      auto imageGeoPredicate = mitk::NodePredicateGeometry::New(image->GetGeometry());
-
       bool sameGeometry = true;
 
       if (dynamic_cast<const mitk::Image*>(node->GetData()) != nullptr)
       {
         sameGeometry = imageGeoPredicate->CheckNode(node);
       }
       else
       {
         const auto planar2 = dynamic_cast<const mitk::PlanarFigure*>(node->GetData());
         if (planar2)
         {
           sameGeometry = mitk::PlanarFigureMaskGenerator::CheckPlanarFigureIsNotTilted(planar2->GetPlaneGeometry(), image->GetGeometry());
         }
       }
 
       return sameGeometry;
     };
 
     result = mitk::NodePredicateAnd::New(isMaskOrPlanarFigurePredicate, mitk::NodePredicateFunction::New(lambda)).GetPointer();
   }
 
   return result;
 }
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.cpp b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.cpp
index e9819deefc..49ab5f61b9 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.cpp
@@ -1,1060 +1,1023 @@
 /*============================================================================
 
 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 "QmitkMultiLabelSegmentationView.h"
 
 // blueberry
 #include <berryConstants.h>
 #include <berryIWorkbenchPage.h>
 
 // mitk
 #include "mitkApplicationCursor.h"
 #include "mitkLabelSetImage.h"
 #include "mitkStatusBar.h"
 #include "mitkToolManagerProvider.h"
 #include "mitkInteractionEventObserver.h"
 #include "mitkPlanePositionManager.h"
 #include "mitkPluginActivator.h"
 #include "mitkSegTool2D.h"
 #include "mitkImageTimeSelector.h"
-#include "mitkNodePredicateFunction.h"
+#include "mitkNodePredicateSubGeometry.h"
 
 // Qmitk
 #include "QmitkNewSegmentationDialog.h"
 #include "QmitkRenderWindow.h"
 #include "QmitkSegmentationOrganNamesHandling.cpp"
 
 // us
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleContext.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 
 // Qt
 #include <QDateTime>
 #include <QFileDialog>
 #include <QInputDialog>
 #include <QMessageBox>
 #include <QShortcut>
 
 #include "tinyxml.h"
 
 #include <itksys/SystemTools.hxx>
 
 #include <regex>
 
 const std::string QmitkMultiLabelSegmentationView::VIEW_ID = "org.mitk.views.multilabelsegmentation";
 
 QmitkMultiLabelSegmentationView::QmitkMultiLabelSegmentationView()
   : m_Parent(nullptr),
     m_IRenderWindowPart(nullptr),
     m_ToolManager(nullptr),
     m_ReferenceNode(nullptr),
     m_WorkingNode(nullptr),
     m_AutoSelectionEnabled(false),
     m_MouseCursorSet(false)
 {
   m_SegmentationPredicate = mitk::NodePredicateAnd::New();
   m_SegmentationPredicate->AddPredicate(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
   m_SegmentationPredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
 
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
   mitk::NodePredicateProperty::Pointer isBinary =
     mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   mitk::NodePredicateAnd::Pointer isMask = mitk::NodePredicateAnd::New(isBinary, isImage);
 
   mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
   mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
   mitk::NodePredicateDataType::Pointer isOdf = mitk::NodePredicateDataType::New("OdfImage");
   auto isSegment = mitk::NodePredicateDataType::New("Segment");
 
   mitk::NodePredicateOr::Pointer validImages = mitk::NodePredicateOr::New();
   validImages->AddPredicate(mitk::NodePredicateAnd::New(isImage, mitk::NodePredicateNot::New(isSegment)));
   validImages->AddPredicate(isDwi);
   validImages->AddPredicate(isDti);
   validImages->AddPredicate(isOdf);
 
   m_ReferencePredicate = mitk::NodePredicateAnd::New();
   m_ReferencePredicate->AddPredicate(validImages);
   m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(m_SegmentationPredicate));
   m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(isMask));
   m_ReferencePredicate->AddPredicate(mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object")));
 }
 
 QmitkMultiLabelSegmentationView::~QmitkMultiLabelSegmentationView()
 {
   // Loose LabelSetConnections
   OnLooseLabelSetConnection();
 }
 
 void QmitkMultiLabelSegmentationView::CreateQtPartControl(QWidget *parent)
 {
   // setup the basic GUI of this view
   m_Parent = parent;
 
   m_Controls.setupUi(parent);
 
   // *------------------------
   // * Shortcuts
   // *------------------------
   QShortcut* visibilityShortcut = new QShortcut(QKeySequence("CTRL+H"), parent);
   connect(visibilityShortcut, &QShortcut::activated, this, &QmitkMultiLabelSegmentationView::OnVisibilityShortcutActivated);
   QShortcut* labelToggleShortcut = new QShortcut(QKeySequence("CTRL+L"), parent);
   connect(labelToggleShortcut, &QShortcut::activated, this, &QmitkMultiLabelSegmentationView::OnLabelToggleShortcutActivated);
 
   // *------------------------
   // * DATA SELECTION WIDGETS
   // *------------------------
 
   m_Controls.m_ReferenceNodeSelector->SetNodePredicate(m_ReferencePredicate);
   m_Controls.m_ReferenceNodeSelector->SetDataStorage(this->GetDataStorage());
   m_Controls.m_ReferenceNodeSelector->SetInvalidInfo("Select an image");
   m_Controls.m_ReferenceNodeSelector->SetPopUpTitel("Select an image");
   m_Controls.m_ReferenceNodeSelector->SetPopUpHint("Select an image that should be used to define the geometry and bounds of the segmentation.");
 
 
   m_Controls.m_WorkingNodeSelector->SetNodePredicate(m_SegmentationPredicate);
   m_Controls.m_WorkingNodeSelector->SetDataStorage(this->GetDataStorage());
   m_Controls.m_WorkingNodeSelector->SetInvalidInfo("Select a segmentation");
   m_Controls.m_WorkingNodeSelector->SetPopUpTitel("Select a segmentation");
   m_Controls.m_WorkingNodeSelector->SetPopUpHint("Select a segmentation that should be modified. Only segmentation with the same geometry and within the bounds of the reference image are selected.");
 
   connect(m_Controls.m_ReferenceNodeSelector,
           &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
           this,&QmitkMultiLabelSegmentationView::OnReferenceSelectionChanged);
   connect(m_Controls.m_WorkingNodeSelector,
           &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged,
           this,&QmitkMultiLabelSegmentationView::OnSegmentationSelectionChanged);
 
   // *------------------------
   // * ToolManager
   // *------------------------
 
   m_ToolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager(mitk::ToolManagerProvider::MULTILABEL_SEGMENTATION);
   m_ToolManager->SetDataStorage(*(this->GetDataStorage()));
   m_ToolManager->InitializeTools();
   m_Controls.m_ManualToolSelectionBox2D->SetToolManager(*m_ToolManager);
   m_Controls.m_ManualToolSelectionBox3D->SetToolManager(*m_ToolManager);
 
   // *------------------------
   // * LabelSetWidget
   // *------------------------
 
   m_Controls.m_LabelSetWidget->SetDataStorage(this->GetDataStorage());
   m_Controls.m_LabelSetWidget->SetOrganColors(mitk::OrganNamesHandling::GetDefaultOrganColorString());
   m_Controls.m_LabelSetWidget->hide();
 
   // *------------------------
   // * Interpolation
   // *------------------------
 
   m_Controls.m_SurfaceBasedInterpolatorWidget->SetDataStorage(*(this->GetDataStorage()));
   m_Controls.m_SliceBasedInterpolatorWidget->SetDataStorage(*(this->GetDataStorage()));
   connect(m_Controls.m_cbInterpolation, SIGNAL(activated(int)), this, SLOT(OnInterpolationSelectionChanged(int)));
 
   m_Controls.m_cbInterpolation->setCurrentIndex(0);
   m_Controls.m_swInterpolation->hide();
 
   m_Controls.m_gbInterpolation->hide(); // See T27436
 
   QString segTools2D = tr("Add Subtract Fill Erase Paint Wipe 'Region Growing' FastMarching2D Correction 'Live Wire'");
   QString segTools3D = tr("Threshold 'Two Thresholds' 'Auto Threshold' 'Multiple Otsu'");
 
   std::regex extSegTool2DRegEx("SegTool2D$");
   std::regex extSegTool3DRegEx("SegTool3D$");
 
   auto tools = m_ToolManager->GetTools();
 
   for (const auto &tool : tools)
   {
     if (std::regex_search(tool->GetNameOfClass(), extSegTool2DRegEx))
     {
       segTools2D.append(QString(" '%1'").arg(tool->GetName()));
     }
     else if (std::regex_search(tool->GetNameOfClass(), extSegTool3DRegEx))
     {
       segTools3D.append(QString(" '%1'").arg(tool->GetName()));
     }
   }
 
   // *------------------------
   // * ToolSelection 2D
   // *------------------------
 
   m_Controls.m_ManualToolSelectionBox2D->SetGenerateAccelerators(true);
   m_Controls.m_ManualToolSelectionBox2D->SetToolGUIArea(m_Controls.m_ManualToolGUIContainer2D);
   m_Controls.m_ManualToolSelectionBox2D->SetDisplayedToolGroups(segTools2D.toStdString()); // todo: "Correction
   // 'Live Wire'"
   m_Controls.m_ManualToolSelectionBox2D->SetEnabledMode(
     QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
   connect(m_Controls.m_ManualToolSelectionBox2D, SIGNAL(ToolSelected(int)), this, SLOT(OnManualTool2DSelected(int)));
 
   // *------------------------
   // * ToolSelection 3D
   // *------------------------
 
   m_Controls.m_ManualToolSelectionBox3D->SetGenerateAccelerators(true);
   m_Controls.m_ManualToolSelectionBox3D->SetToolGUIArea(m_Controls.m_ManualToolGUIContainer3D);
   m_Controls.m_ManualToolSelectionBox3D->SetDisplayedToolGroups(segTools3D.toStdString()); // todo add : FastMarching3D RegionGrowing Watershed
   m_Controls.m_ManualToolSelectionBox3D->SetLayoutColumns(2);
   m_Controls.m_ManualToolSelectionBox3D->SetEnabledMode(
     QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
 
   // *------------------------*
   // * Connect PushButtons (pb)
   // *------------------------*
 
   connect(m_Controls.m_pbNewLabel, SIGNAL(clicked()), this, SLOT(OnNewLabel()));
   connect(m_Controls.m_pbNewSegmentationSession, SIGNAL(clicked()), this, SLOT(OnNewSegmentationSession()));
   connect(m_Controls.m_pbShowLabelTable, SIGNAL(toggled(bool)), this, SLOT(OnShowLabelTable(bool)));
 
   // *------------------------*
   // * Connect LabelSetWidget
   // *------------------------*
 
   connect(m_Controls.m_LabelSetWidget,
           SIGNAL(goToLabel(const mitk::Point3D &)),
           this,
           SLOT(OnGoToLabel(const mitk::Point3D &)));
   connect(m_Controls.m_LabelSetWidget, SIGNAL(resetView()), this, SLOT(OnResetView()));
 
   // *------------------------*
   // * DATA SLECTION WIDGET
   // *------------------------*
   m_IRenderWindowPart = this->GetRenderWindowPart();
   if (m_IRenderWindowPart)
   {
     QList<mitk::SliceNavigationController *> controllers;
     controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
     controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
     controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
     m_Controls.m_SliceBasedInterpolatorWidget->SetSliceNavigationControllers(controllers);
   }
 
   //  this->InitializeListeners();
 
   connect(m_Controls.m_btAddLayer, SIGNAL(clicked()), this, SLOT(OnAddLayer()));
   connect(m_Controls.m_btDeleteLayer, SIGNAL(clicked()), this, SLOT(OnDeleteLayer()));
   connect(m_Controls.m_btPreviousLayer, SIGNAL(clicked()), this, SLOT(OnPreviousLayer()));
   connect(m_Controls.m_btNextLayer, SIGNAL(clicked()), this, SLOT(OnNextLayer()));
   connect(m_Controls.m_btLockExterior, SIGNAL(toggled(bool)), this, SLOT(OnLockExteriorToggled(bool)));
   connect(m_Controls.m_cbActiveLayer, SIGNAL(currentIndexChanged(int)), this, SLOT(OnChangeLayer(int)));
 
   m_Controls.m_btAddLayer->setEnabled(false);
   m_Controls.m_btDeleteLayer->setEnabled(false);
   m_Controls.m_btNextLayer->setEnabled(false);
   m_Controls.m_btPreviousLayer->setEnabled(false);
   m_Controls.m_cbActiveLayer->setEnabled(false);
 
   m_Controls.m_pbNewLabel->setEnabled(false);
   m_Controls.m_btLockExterior->setEnabled(false);
   m_Controls.m_pbShowLabelTable->setEnabled(false);
 
   // Make sure the GUI notices if appropriate data is already present on creation
   m_Controls.m_ReferenceNodeSelector->SetAutoSelectNewNodes(true);
   m_Controls.m_WorkingNodeSelector->SetAutoSelectNewNodes(true);
 }
 
 void QmitkMultiLabelSegmentationView::Activated()
 {
   m_ToolManager->SetReferenceData(m_Controls.m_ReferenceNodeSelector->GetSelectedNode());
   m_ToolManager->SetWorkingData(m_Controls.m_WorkingNodeSelector->GetSelectedNode());
 }
 
 void QmitkMultiLabelSegmentationView::Deactivated()
 {
   // Not yet implemented
 }
 
 void QmitkMultiLabelSegmentationView::Visible()
 {
   // Not yet implemented
 }
 
 void QmitkMultiLabelSegmentationView::Hidden()
 {
   // Not yet implemented
 }
 
 int QmitkMultiLabelSegmentationView::GetSizeFlags(bool width)
 {
   if (!width)
   {
     return berry::Constants::MIN | berry::Constants::MAX | berry::Constants::FILL;
   }
   else
   {
     return 0;
   }
 }
 
 int QmitkMultiLabelSegmentationView::ComputePreferredSize(bool width,
                                                           int /*availableParallel*/,
                                                           int /*availablePerpendicular*/,
                                                           int preferredResult)
 {
   if (width == false)
   {
     return 100;
   }
   else
   {
     return preferredResult;
   }
 }
 
 /************************************************************************/
 /* protected slots                                                      */
 /************************************************************************/
 void QmitkMultiLabelSegmentationView::OnVisibilityShortcutActivated()
 {
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
 
   bool isVisible = false;
   workingNode->GetBoolProperty("visible", isVisible);
   workingNode->SetVisibility(!isVisible);
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkMultiLabelSegmentationView::OnLabelToggleShortcutActivated()
 {
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
 
   mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
   assert(workingImage);
 
   WaitCursorOn();
   workingImage->GetActiveLabelSet()->SetNextActiveLabel();
   workingImage->Modified();
   WaitCursorOff();
 
   mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkMultiLabelSegmentationView::OnManualTool2DSelected(int id)
 {
   this->ResetMouseCursor();
   mitk::StatusBar::GetInstance()->DisplayText("");
 
   if (id >= 0)
   {
     std::string text = "Active Tool: \"";
     text += m_ToolManager->GetToolById(id)->GetName();
     text += "\"";
     mitk::StatusBar::GetInstance()->DisplayText(text.c_str());
 
     us::ModuleResource resource = m_ToolManager->GetToolById(id)->GetCursorIconResource();
     this->SetMouseCursor(resource, 0, 0);
   }
 }
 
 void QmitkMultiLabelSegmentationView::OnNewLabel()
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
   if (!workingNode)
   {
     QMessageBox::information(
       m_Parent, "New Segmentation Session", "Please load and select a patient image before starting some action.");
     return;
   }
 
   mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
   if (!workingImage)
   {
     QMessageBox::information(
       m_Parent, "New Segmentation Session", "Please load and select a patient image before starting some action.");
     return;
   }
 
   QmitkNewSegmentationDialog* dialog = new QmitkNewSegmentationDialog(m_Parent);
   dialog->SetSuggestionList(mitk::OrganNamesHandling::GetDefaultOrganColorString());
   dialog->setWindowTitle("New Label");
 
   int dialogReturnValue = dialog->exec();
   if (dialogReturnValue == QDialog::Rejected)
   {
     return;
   }
 
   QString segName = dialog->GetSegmentationName();
   if (segName.isEmpty())
   {
     segName = "Unnamed";
   }
   workingImage->GetActiveLabelSet()->AddLabel(segName.toStdString(), dialog->GetColor());
 
   UpdateControls();
   m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
 
   mitk::RenderingManager::GetInstance()->InitializeViews(workingNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
 }
 
 void QmitkMultiLabelSegmentationView::OnShowLabelTable(bool value)
 {
   if (value)
     m_Controls.m_LabelSetWidget->show();
   else
     m_Controls.m_LabelSetWidget->hide();
 }
 
 void QmitkMultiLabelSegmentationView::OnNewSegmentationSession()
 {
   mitk::DataNode *referenceNode = m_Controls.m_ReferenceNodeSelector->GetSelectedNode();
 
   if (!referenceNode)
   {
     QMessageBox::information(
       m_Parent, "New Segmentation Session", "Please load and select a patient image before starting some action.");
     return;
   }
 
   m_ToolManager->ActivateTool(-1);
 
   mitk::Image::ConstPointer referenceImage = dynamic_cast<mitk::Image*>(referenceNode->GetData());
   assert(referenceImage);
 
   if (referenceImage->GetDimension() > 3)
   {
     auto result = QMessageBox::question(m_Parent, tr("Generate a static mask?"), tr("The selected image has multiple time steps. You can either generate a simple/static masks resembling the geometry of the first timestep of the image. Or you can generate a dynamic mask that equals the selected image in geometry and number of timesteps; thus a dynamic mask can change over time (e.g. according to the image)."), tr("Yes, generate a static mask"), tr("No, generate a dynamic mask"), QString(), 0, 0);
     if (result == 0)
     {
       auto selector = mitk::ImageTimeSelector::New();
       selector->SetInput(referenceImage);
       selector->SetTimeNr(0);
       selector->Update();
 
       const auto refTimeGeometry = referenceImage->GetTimeGeometry();
       auto newTimeGeometry = mitk::ProportionalTimeGeometry::New();
       newTimeGeometry->SetFirstTimePoint(refTimeGeometry->GetMinimumTimePoint());
       newTimeGeometry->SetStepDuration(refTimeGeometry->GetMaximumTimePoint() - refTimeGeometry->GetMinimumTimePoint());
 
       mitk::Image::Pointer newImage = selector->GetOutput();
       newTimeGeometry->SetTimeStepGeometry(referenceImage->GetGeometry(), 0);
       newImage->SetTimeGeometry(newTimeGeometry);
       referenceImage = newImage;
     }
   }
 
   QString newName = QString::fromStdString(referenceNode->GetName());
   newName.append("-labels");
 
   bool ok = false;
   newName = QInputDialog::getText(m_Parent, "New Segmentation Session", "New name:", QLineEdit::Normal, newName, &ok);
 
   if (!ok)
   {
     return;
   }
   this->WaitCursorOn();
 
   mitk::LabelSetImage::Pointer workingImage = mitk::LabelSetImage::New();
   try
   {
     workingImage->Initialize(referenceImage);
   }
   catch (mitk::Exception& e)
   {
     this->WaitCursorOff();
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(m_Parent, "New Segmentation Session", "Could not create a new segmentation session.\n");
     return;
   }
 
   this->WaitCursorOff();
 
   mitk::DataNode::Pointer workingNode = mitk::DataNode::New();
   workingNode->SetData(workingImage);
   workingNode->SetName(newName.toStdString());
 
   workingImage->GetExteriorLabel()->SetProperty("name.parent", mitk::StringProperty::New(referenceNode->GetName().c_str()));
   workingImage->GetExteriorLabel()->SetProperty("name.image", mitk::StringProperty::New(newName.toStdString().c_str()));
 
   if (!GetDataStorage()->Exists(workingNode))
   {
     GetDataStorage()->Add(workingNode, referenceNode);
   }
 
   m_Controls.m_WorkingNodeSelector->SetCurrentSelectedNode(workingNode);
 
   OnNewLabel();
 }
 
 void QmitkMultiLabelSegmentationView::OnGoToLabel(const mitk::Point3D& pos)
 {
   if (m_IRenderWindowPart)
     m_IRenderWindowPart->SetSelectedPosition(pos);
 }
 
 void QmitkMultiLabelSegmentationView::OnResetView()
 {
   if (m_IRenderWindowPart)
     m_IRenderWindowPart->ForceImmediateUpdate();
 }
 
 void QmitkMultiLabelSegmentationView::OnAddLayer()
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
 
   mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
   assert(workingImage);
 
   QString question = "Do you really want to add a layer to the current segmentation session?";
   QMessageBox::StandardButton answerButton = QMessageBox::question(
     m_Controls.m_LabelSetWidget, "Add layer", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton != QMessageBox::Yes) return;
 
   try
   {
     WaitCursorOn();
     workingImage->AddLayer();
     WaitCursorOff();
   }
   catch ( mitk::Exception& e )
   {
     WaitCursorOff();
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(
       m_Controls.m_LabelSetWidget, "Add Layer", "Could not add a new layer. See error log for details.\n");
     return;
   }
 
   OnNewLabel();
 }
 
 void QmitkMultiLabelSegmentationView::OnDeleteLayer()
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
 
   mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
   assert(workingImage);
 
   if (workingImage->GetNumberOfLayers() < 2)
     return;
 
   QString question = "Do you really want to delete the current layer?";
 
   QMessageBox::StandardButton answerButton = QMessageBox::question(
     m_Controls.m_LabelSetWidget, "Delete layer", question, QMessageBox::Yes | QMessageBox::Cancel, QMessageBox::Yes);
 
   if (answerButton != QMessageBox::Yes)
   {
     return;
   }
 
   try
   {
     this->WaitCursorOn();
     workingImage->RemoveLayer();
     this->WaitCursorOff();
   }
   catch (mitk::Exception& e)
   {
     this->WaitCursorOff();
     MITK_ERROR << "Exception caught: " << e.GetDescription();
     QMessageBox::information(m_Controls.m_LabelSetWidget, "Delete Layer",
                              "Could not delete the currently active layer. See error log for details.\n");
     return;
   }
 
   UpdateControls();
   m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
 }
 
 void QmitkMultiLabelSegmentationView::OnPreviousLayer()
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
   mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
   assert(workingImage);
 
   OnChangeLayer(workingImage->GetActiveLayer() - 1);
 }
 
 void QmitkMultiLabelSegmentationView::OnNextLayer()
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
   mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
   assert(workingImage);
 
   OnChangeLayer(workingImage->GetActiveLayer() + 1);
 }
 
 void QmitkMultiLabelSegmentationView::OnChangeLayer(int layer)
 {
   m_ToolManager->ActivateTool(-1);
 
   mitk::DataNode *workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
 
   mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(workingNode->GetData());
   assert(workingImage);
 
   this->WaitCursorOn();
   workingImage->SetActiveLayer(layer);
   this->WaitCursorOff();
 
   UpdateControls();
   m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
 }
 
 void QmitkMultiLabelSegmentationView::OnDeactivateActiveTool()
 {
   m_ToolManager->ActivateTool(-1);
 }
 
 void QmitkMultiLabelSegmentationView::OnLockExteriorToggled(bool checked)
 {
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
   assert(workingNode);
 
   mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
   assert(workingImage);
 
   workingImage->GetLabel(0)->SetLocked(checked);
 }
 
 void QmitkMultiLabelSegmentationView::OnReferenceSelectionChanged(QList<mitk::DataNode::Pointer> /*nodes*/)
 {
   m_ToolManager->ActivateTool(-1);
 
   auto refNode = m_Controls.m_ReferenceNodeSelector->GetSelectedNode();
   m_ReferenceNode = refNode;
   m_ToolManager->SetReferenceData(m_ReferenceNode);
 
   if (m_ReferenceNode.IsNotNull())
   {
-    auto geometryCheck = [refNode](const mitk::DataNode * segNode)
-    {
-      return QmitkMultiLabelSegmentationView::CheckForSameGeometry(refNode,segNode);
-    };
-
-    mitk::NodePredicateFunction::Pointer hasCorrectGeo = mitk::NodePredicateFunction::New(geometryCheck);
-    auto segPredicate = mitk::NodePredicateAnd::New(m_SegmentationPredicate.GetPointer(), hasCorrectGeo.GetPointer());
+    auto segPredicate = mitk::NodePredicateAnd::New(m_SegmentationPredicate.GetPointer(), mitk::NodePredicateSubGeometry::New(refNode->GetData()->GetGeometry()));
 
     m_Controls.m_WorkingNodeSelector->SetNodePredicate(segPredicate);
 
     if (m_AutoSelectionEnabled)
     {
       // hide all image nodes to later show only the automatically selected ones
       mitk::DataStorage::SetOfObjects::ConstPointer patientNodes = GetDataStorage()->GetSubset(m_ReferencePredicate);
       for (mitk::DataStorage::SetOfObjects::const_iterator iter = patientNodes->begin(); iter != patientNodes->end(); ++iter)
       {
         (*iter)->SetVisibility(false);
       }
     }
     m_ReferenceNode->SetVisibility(true);
   }
 
   UpdateControls();
 }
 
 void QmitkMultiLabelSegmentationView::OnSegmentationSelectionChanged(QList<mitk::DataNode::Pointer> /*nodes*/)
 {
   m_ToolManager->ActivateTool(-1);
 
   if (m_WorkingNode.IsNotNull())
     OnLooseLabelSetConnection();
 
   m_WorkingNode = m_Controls.m_WorkingNodeSelector->GetSelectedNode();
   m_ToolManager->SetWorkingData(m_WorkingNode);
   if (m_WorkingNode.IsNotNull())
   {
     OnEstablishLabelSetConnection();
 
     if (m_AutoSelectionEnabled)
     {
       // hide all segmentation nodes to later show only the automatically selected ones
       mitk::DataStorage::SetOfObjects::ConstPointer segmentationNodes = GetDataStorage()->GetSubset(m_SegmentationPredicate);
       for (mitk::DataStorage::SetOfObjects::const_iterator iter = segmentationNodes->begin(); iter != segmentationNodes->end(); ++iter)
       {
         (*iter)->SetVisibility(false);
       }
     }
     m_WorkingNode->SetVisibility(true);
   }
 
   UpdateControls();
   if (m_WorkingNode.IsNotNull())
   {
     m_Controls.m_LabelSetWidget->ResetAllTableWidgetItems();
     mitk::RenderingManager::GetInstance()->InitializeViews(m_WorkingNode->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
   }
 }
 
 void QmitkMultiLabelSegmentationView::OnInterpolationSelectionChanged(int index)
 {
   if (index == 1)
   {
     m_Controls.m_SurfaceBasedInterpolatorWidget->m_Controls.m_btStart->setChecked(false);//OnToggleWidgetActivation(false);
     m_Controls.m_swInterpolation->setCurrentIndex(0);
     m_Controls.m_swInterpolation->show();
   }
   else if (index == 2)
   {
     m_Controls.m_SliceBasedInterpolatorWidget->m_Controls.m_btStart->setChecked(false);
     m_Controls.m_swInterpolation->setCurrentIndex(1);
     m_Controls.m_swInterpolation->show();
   }
   else
   {
     m_Controls.m_SurfaceBasedInterpolatorWidget->m_Controls.m_btStart->setChecked(false);
     m_Controls.m_SliceBasedInterpolatorWidget->m_Controls.m_btStart->setChecked(false);
     m_Controls.m_swInterpolation->setCurrentIndex(2);
     m_Controls.m_swInterpolation->hide();
   }
 }
 
 /************************************************************************/
 /* protected                                                            */
 /************************************************************************/
 void QmitkMultiLabelSegmentationView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
 {
   if (m_Parent && m_WorkingNode.IsNotNull())
   {
     m_AutoSelectionEnabled = prefs->GetBool("auto selection", false);
 
     mitk::BoolProperty::Pointer drawOutline = mitk::BoolProperty::New(prefs->GetBool("draw outline", true));
     mitk::BoolProperty::Pointer volumeRendering = mitk::BoolProperty::New(prefs->GetBool("volume rendering", false));
     mitk::LabelSetImage* labelSetImage;
     mitk::DataNode* segmentation;
 
     // iterate all segmentations (binary (single label) and LabelSetImages)
     mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
     mitk::NodePredicateOr::Pointer allSegmentationsPredicate = mitk::NodePredicateOr::New(isBinaryPredicate, m_SegmentationPredicate);
     mitk::DataStorage::SetOfObjects::ConstPointer allSegmentations = GetDataStorage()->GetSubset(allSegmentationsPredicate);
 
     for (mitk::DataStorage::SetOfObjects::const_iterator it = allSegmentations->begin(); it != allSegmentations->end(); ++it)
     {
       segmentation = *it;
       labelSetImage = dynamic_cast<mitk::LabelSetImage*>(segmentation->GetData());
       if (nullptr != labelSetImage)
       {
         // segmentation node is a multi label segmentation
         segmentation->SetProperty("labelset.contour.active", drawOutline);
         //segmentation->SetProperty("opacity", mitk::FloatProperty::New(drawOutline->GetValue() ? 1.0f : 0.3f));
         segmentation->SetProperty("volumerendering", volumeRendering);
         // force render window update to show outline
         segmentation->GetData()->Modified();
       }
       else if (nullptr != segmentation->GetData())
       {
         // node is actually a 'single label' segmentation,
         // but its outline property can be set in the 'multi label' segmentation preference page as well
         bool isBinary = false;
         segmentation->GetBoolProperty("binary", isBinary);
         if (isBinary)
         {
           segmentation->SetProperty("outline binary", drawOutline);
           segmentation->SetProperty("outline width", mitk::FloatProperty::New(2.0));
           //segmentation->SetProperty("opacity", mitk::FloatProperty::New(drawOutline->GetValue() ? 1.0f : 0.3f));
           segmentation->SetProperty("volumerendering", volumeRendering);
           // force render window update to show outline
           segmentation->GetData()->Modified();
         }
       }
       else
       {
         // "interpolation feedback" data nodes have binary flag but don't have a data set. So skip them for now.
         MITK_INFO << "DataNode " << segmentation->GetName() << " doesn't contain a base data.";
       }
     }
   }
 }
 
 void QmitkMultiLabelSegmentationView::NodeRemoved(const mitk::DataNode *node)
 {
   bool isHelperObject(false);
   node->GetBoolProperty("helper object", isHelperObject);
   if (isHelperObject)
   {
     return;
   }
 
   if (m_ReferenceNode.IsNotNull() && dynamic_cast<mitk::LabelSetImage *>(node->GetData()))
   {
     // remove all possible contour markers of the segmentation
     mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers = this->GetDataStorage()->GetDerivations(
       node, mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true)));
 
     ctkPluginContext *context = mitk::PluginActivator::getContext();
     ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
     mitk::PlanePositionManagerService *service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
 
     for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End(); ++it)
     {
       std::string nodeName = node->GetName();
       unsigned int t = nodeName.find_last_of(" ");
       unsigned int id = atof(nodeName.substr(t + 1).c_str()) - 1;
 
       service->RemovePlanePosition(id);
 
       this->GetDataStorage()->Remove(it->Value());
     }
 
     context->ungetService(ppmRef);
     service = nullptr;
   }
 }
 
 void QmitkMultiLabelSegmentationView::OnEstablishLabelSetConnection()
 {
   if (m_WorkingNode.IsNull())
   {
     return;
   }
   mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(m_WorkingNode->GetData());
   assert(workingImage);
 
   workingImage->GetActiveLabelSet()->AddLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->RemoveLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->ModifyLabelEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->AllLabelsModifiedEvent += mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->ActiveLabelEvent +=
     mitk::MessageDelegate1<QmitkLabelSetWidget, mitk::Label::PixelType>(m_Controls.m_LabelSetWidget,
                                                                         &QmitkLabelSetWidget::SelectLabelByPixelValue);
   workingImage->BeforeChangeLayerEvent += mitk::MessageDelegate<QmitkMultiLabelSegmentationView>(
     this, &QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection);
 }
 
 void QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection()
 {
   if (m_WorkingNode.IsNull())
   {
     return;
   }
   mitk::LabelSetImage *workingImage = dynamic_cast<mitk::LabelSetImage *>(m_WorkingNode->GetData());
   assert(workingImage);
 
   // Reset LabelSetWidget Events
   workingImage->GetActiveLabelSet()->AddLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->RemoveLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::ResetAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->ModifyLabelEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->AllLabelsModifiedEvent -= mitk::MessageDelegate<QmitkLabelSetWidget>(
     m_Controls.m_LabelSetWidget, &QmitkLabelSetWidget::UpdateAllTableWidgetItems);
   workingImage->GetActiveLabelSet()->ActiveLabelEvent -=
     mitk::MessageDelegate1<QmitkLabelSetWidget, mitk::Label::PixelType>(m_Controls.m_LabelSetWidget,
                                                                         &QmitkLabelSetWidget::SelectLabelByPixelValue);
   workingImage->BeforeChangeLayerEvent -= mitk::MessageDelegate<QmitkMultiLabelSegmentationView>(
     this, &QmitkMultiLabelSegmentationView::OnLooseLabelSetConnection);
 }
 
 void QmitkMultiLabelSegmentationView::SetFocus()
 {
 }
 
 void QmitkMultiLabelSegmentationView::UpdateControls()
 {
   mitk::DataNode* referenceNode = m_ToolManager->GetReferenceData(0);
   bool hasReferenceNode = referenceNode != nullptr;
 
   mitk::DataNode* workingNode = m_ToolManager->GetWorkingData(0);
   bool hasValidWorkingNode = workingNode != nullptr;
 
   m_Controls.m_pbNewLabel->setEnabled(false);
   m_Controls.m_gbInterpolation->setEnabled(false);
   m_Controls.m_SliceBasedInterpolatorWidget->setEnabled(false);
   m_Controls.m_SurfaceBasedInterpolatorWidget->setEnabled(false);
   m_Controls.m_LabelSetWidget->setEnabled(false);
   m_Controls.m_btAddLayer->setEnabled(false);
   m_Controls.m_btDeleteLayer->setEnabled(false);
   m_Controls.m_cbActiveLayer->setEnabled(false);
   m_Controls.m_btPreviousLayer->setEnabled(false);
   m_Controls.m_btNextLayer->setEnabled(false);
   m_Controls.m_btLockExterior->setChecked(false);
   m_Controls.m_btLockExterior->setEnabled(false);
   m_Controls.m_pbShowLabelTable->setChecked(false);
   m_Controls.m_pbShowLabelTable->setEnabled(false);
 
   m_Controls.m_ManualToolSelectionBox3D->SetEnabledMode(QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
   m_Controls.m_ManualToolSelectionBox2D->SetEnabledMode(QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
 
   if (hasValidWorkingNode)
   {
     // TODO adapt tool manager so that this check is done there, e.g. convenience function
     mitk::LabelSetImage* workingImage = dynamic_cast<mitk::LabelSetImage*>(workingNode->GetData());
     hasValidWorkingNode = workingImage != nullptr;
     if (hasValidWorkingNode)
     {
       m_Controls.m_pbNewLabel->setEnabled(true);
       m_Controls.m_btLockExterior->setEnabled(true);
       m_Controls.m_pbShowLabelTable->setEnabled(true);
       m_Controls.m_gbInterpolation->setEnabled(true);
       m_Controls.m_SliceBasedInterpolatorWidget->setEnabled(true);
       m_Controls.m_SurfaceBasedInterpolatorWidget->setEnabled(true);
       m_Controls.m_LabelSetWidget->setEnabled(true);
       m_Controls.m_btAddLayer->setEnabled(true);
 
       int activeLayer = workingImage->GetActiveLayer();
       int numberOfLayers = workingImage->GetNumberOfLayers();
 
       m_Controls.m_cbActiveLayer->blockSignals(true);
       m_Controls.m_cbActiveLayer->clear();
       for (unsigned int lidx = 0; lidx < workingImage->GetNumberOfLayers(); ++lidx)
       {
         m_Controls.m_cbActiveLayer->addItem(QString::number(lidx));
       }
       m_Controls.m_cbActiveLayer->setCurrentIndex(activeLayer);
       m_Controls.m_cbActiveLayer->blockSignals(false);
 
       m_Controls.m_cbActiveLayer->setEnabled(numberOfLayers > 1);
       m_Controls.m_btDeleteLayer->setEnabled(numberOfLayers > 1);
       m_Controls.m_btPreviousLayer->setEnabled(activeLayer > 0);
       m_Controls.m_btNextLayer->setEnabled(activeLayer != numberOfLayers - 1);
 
       m_Controls.m_btLockExterior->setChecked(workingImage->GetLabel(0, activeLayer)->GetLocked());
       m_Controls.m_pbShowLabelTable->setChecked(workingImage->GetNumberOfLabels() > 1 /*1st is exterior*/);
 
       //MLI TODO
       //m_Controls.m_ManualToolSelectionBox2D->SetEnabledMode(QmitkToolSelectionBox::EnabledWithWorkingDataVisible);
     }
   }
 
   if (hasValidWorkingNode && hasReferenceNode)
   {
     int layer = -1;
     referenceNode->GetIntProperty("layer", layer);
     workingNode->SetIntProperty("layer", layer + 1);
   }
 
   this->RequestRenderWindowUpdate(mitk::RenderingManager::REQUEST_UPDATE_ALL);
 }
 
 void QmitkMultiLabelSegmentationView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_IRenderWindowPart != renderWindowPart)
   {
     m_IRenderWindowPart = renderWindowPart;
     m_Parent->setEnabled(true);
 
     QList<mitk::SliceNavigationController*> controllers;
     controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
     controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
     controllers.push_back(m_IRenderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
     m_Controls.m_SliceBasedInterpolatorWidget->SetSliceNavigationControllers(controllers);
   }
 }
 
 void QmitkMultiLabelSegmentationView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_ToolManager->ActivateTool(-1);
   m_IRenderWindowPart = nullptr;
   m_Parent->setEnabled(false);
 }
 
 void QmitkMultiLabelSegmentationView::ResetMouseCursor()
 {
   if (m_MouseCursorSet)
   {
     mitk::ApplicationCursor::GetInstance()->PopCursor();
     m_MouseCursorSet = false;
   }
 }
 
 void QmitkMultiLabelSegmentationView::SetMouseCursor(const us::ModuleResource resource, int hotspotX, int hotspotY)
 {
   // Remove previously set mouse cursor
   if (m_MouseCursorSet)
     this->ResetMouseCursor();
 
   if (resource)
   {
     us::ModuleResourceStream cursor(resource, std::ios::binary);
     mitk::ApplicationCursor::GetInstance()->PushCursor(cursor, hotspotX, hotspotY);
     m_MouseCursorSet = true;
   }
 }
 
 void QmitkMultiLabelSegmentationView::InitializeListeners()
 {
   if (m_Interactor.IsNull())
   {
     us::Module* module = us::GetModuleContext()->GetModule();
     std::vector<us::ModuleResource> resources = module->FindResources("/", "*", true);
     for (std::vector<us::ModuleResource>::iterator iter = resources.begin(); iter != resources.end(); ++iter)
     {
       MITK_INFO << iter->GetResourcePath();
     }
 
     m_Interactor = mitk::SegmentationInteractor::New();
     if (!m_Interactor->LoadStateMachine("SegmentationInteraction.xml", module))
     {
       MITK_WARN << "Error loading state machine";
     }
 
     if (!m_Interactor->SetEventConfig("ConfigSegmentation.xml", module))
     {
       MITK_WARN << "Error loading state machine configuration";
     }
 
     // Register as listener via micro services
     us::ServiceProperties props;
     props["name"] = std::string("SegmentationInteraction");
     m_ServiceRegistration =
       us::GetModuleContext()->RegisterService<mitk::InteractionEventObserver>(m_Interactor.GetPointer(), props);
   }
 }
-
-bool QmitkMultiLabelSegmentationView::CheckForSameGeometry(const mitk::DataNode *node1, const mitk::DataNode *node2)
-{
-  bool isSameGeometry(true);
-
-  auto image1 = dynamic_cast<const mitk::Image*>(node1->GetData());
-  assert(image1);
-
-  auto image2 = dynamic_cast<const mitk::Image*>(node2->GetData());
-  assert(image2);
-
-  if (image1 && image2)
-  {
-    mitk::BaseGeometry::Pointer geo1 = image1->GetGeometry();
-    mitk::BaseGeometry::Pointer geo2 = image2->GetGeometry();
-
-    isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetOrigin(), geo2->GetOrigin());
-    isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(0), geo2->GetExtent(0));
-    isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(1), geo2->GetExtent(1));
-    isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(2), geo2->GetExtent(2));
-    isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetSpacing(), geo2->GetSpacing());
-    isSameGeometry = isSameGeometry && mitk::MatrixEqualElementWise(geo1->GetIndexToWorldTransform()->GetMatrix(),
-                                                                    geo2->GetIndexToWorldTransform()->GetMatrix());
-
-    return isSameGeometry;
-  }
-  else
-  {
-    return false;
-  }
-}
diff --git a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.h b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.h
index e8ec36913e..345e404897 100644
--- a/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.h
+++ b/Plugins/org.mitk.gui.qt.multilabelsegmentation/src/internal/QmitkMultiLabelSegmentationView.h
@@ -1,172 +1,169 @@
 /*============================================================================
 
 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 QmitkMultiLabelSegmentationView_h
 #define QmitkMultiLabelSegmentationView_h
 
 #include <QmitkAbstractView.h>
 
 #include "mitkSegmentationInteractor.h"
 #include <mitkILifecycleAwarePart.h>
 
 #include "ui_QmitkMultiLabelSegmentationControls.h"
 
 // berry
 #include <berryIBerryPreferences.h>
 
 class QmitkRenderWindow;
 
 /**
  * \ingroup ToolManagerEtAl
  * \ingroup org_mitk_gui_qt_multilabelsegmentation_internal
  */
 class QmitkMultiLabelSegmentationView : public QmitkAbstractView, public mitk::ILifecycleAwarePart
 {
   Q_OBJECT
 
 public:
   static const std::string VIEW_ID;
 
   QmitkMultiLabelSegmentationView();
   ~QmitkMultiLabelSegmentationView() override;
 
   typedef std::map<mitk::DataNode *, unsigned long> NodeTagMapType;
 
   // GUI setup
   void CreateQtPartControl(QWidget *parent) override;
 
   // ILifecycleAwarePart interface
 public:
   void Activated() override;
   void Deactivated() override;
   void Visible() override;
   void Hidden() override;
 
   virtual int GetSizeFlags(bool width);
   virtual int ComputePreferredSize(bool width,
                                    int /*availableParallel*/,
                                    int /*availablePerpendicular*/,
                                    int preferredResult);
 
 protected slots:
 
   // reaction to the shortcut for toggling the visibility of the working node
   void OnVisibilityShortcutActivated();
 
   // reaction to the shortcut for iterating over all labels
   void OnLabelToggleShortcutActivated();
 
   // reaction to the selection of any 2D segmentation tool
   void OnManualTool2DSelected(int id);
 
   // reaction to button "New Label"
   void OnNewLabel();
 
   // reaction to button "Show Label Table"
   void OnShowLabelTable(bool value);
 
   // reaction to button "New Segmentation Session"
   void OnNewSegmentationSession();
 
   // reaction to signal "goToLabel" from labelset widget
   void OnGoToLabel(const mitk::Point3D &pos);
 
   void OnResetView();
 
   // reaction to the button "Add Layer"
   void OnAddLayer();
 
   // reaction to the button "Delete Layer"
   void OnDeleteLayer();
 
   // reaction to the button "Previous Layer"
   void OnPreviousLayer();
 
   // reaction to the button "Next Layer"
   void OnNextLayer();
 
   // reaction to the combobox change "Change Layer"
   void OnChangeLayer(int);
 
   // reaction to the button "Deactive Active Tool"
   void OnDeactivateActiveTool();
 
   // reaction to the button "Lock exterior"
   void OnLockExteriorToggled(bool);
 
   // reaction to the selection of a new patient (reference) image in the DataStorage combobox
   void OnReferenceSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
 
   // reaction to the selection of a new Segmentation (working) image in the DataStorage combobox
   void OnSegmentationSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
 
   // reaction to ...
   void OnInterpolationSelectionChanged(int);
 
 protected:
 
   // reimplemented from QmitkAbstractView
   void OnPreferencesChanged(const berry::IBerryPreferences* prefs) override;
 
   // reimplemented from QmitkAbstractView
   void NodeRemoved(const mitk::DataNode* node) override;
 
   void OnEstablishLabelSetConnection();
 
   void OnLooseLabelSetConnection();
 
   void SetFocus() override;
 
   void UpdateControls();
 
   void RenderWindowPartActivated(mitk::IRenderWindowPart *renderWindowPart);
 
   void RenderWindowPartDeactivated(mitk::IRenderWindowPart *renderWindowPart);
 
   void ResetMouseCursor();
 
   void SetMouseCursor(const us::ModuleResource, int hotspotX, int hotspotY);
 
   void InitializeListeners();
 
-  /// \brief Checks if two images have the same size and geometry
-  static bool CheckForSameGeometry(const mitk::DataNode *node1, const mitk::DataNode *node2);
-
   /// \brief the Qt parent of our GUI (NOT of this object)
   QWidget *m_Parent;
 
   /// \brief Qt GUI file
   Ui::QmitkMultiLabelSegmentationControls m_Controls;
 
   mitk::IRenderWindowPart *m_IRenderWindowPart;
 
   mitk::ToolManager *m_ToolManager;
 
   mitk::DataNode::Pointer m_ReferenceNode;
   mitk::DataNode::Pointer m_WorkingNode;
 
   mitk::NodePredicateAnd::Pointer m_ReferencePredicate;
   mitk::NodePredicateAnd::Pointer m_SegmentationPredicate;
 
   bool m_AutoSelectionEnabled;
   bool m_MouseCursorSet;
 
   mitk::SegmentationInteractor::Pointer m_Interactor;
 
   /**
    * Reference to the service registration of the observer,
    * it is needed to unregister the observer on unload.
    */
   us::ServiceRegistration<mitk::InteractionEventObserver> m_ServiceRegistration;
 };
 
 #endif // QmitkMultiLabelSegmentationView_h
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
index 02089e0da9..b60fa47186 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.cpp
@@ -1,925 +1,894 @@
 /*============================================================================
 
 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 <QObject>
 
 #include "mitkProperties.h"
 #include "mitkSegTool2D.h"
 #include "mitkStatusBar.h"
 
 #include "QmitkNewSegmentationDialog.h"
 #include <QmitkSegmentationOrganNamesHandling.cpp>
 
 #include <QMessageBox>
 
 #include <berryIWorkbenchPage.h>
 
 #include "QmitkSegmentationView.h"
 
 #include <mitkSurfaceToImageFilter.h>
 
 #include "mitkVtkResliceInterpolationProperty.h"
 
 #include "mitkApplicationCursor.h"
 #include "mitkSegmentationObjectFactory.h"
 #include "mitkPluginActivator.h"
 #include "mitkCameraController.h"
 #include "mitkLabelSetImage.h"
 #include "mitkImageTimeSelector.h"
-#include "mitkNodePredicateFunction.h"
+#include "mitkNodePredicateSubGeometry.h"
 
 #include <QmitkRenderWindow.h>
 
 #include "usModuleResource.h"
 #include "usModuleResourceStream.h"
 
 //micro service to get the ToolManager instance
 #include "mitkToolManagerProvider.h"
 
 #include <mitkWorkbenchUtil.h>
 #include <regex>
 
 const std::string QmitkSegmentationView::VIEW_ID = "org.mitk.views.segmentation";
 
 QmitkSegmentationView::QmitkSegmentationView()
   : m_Parent(nullptr)
   , m_Controls(nullptr)
   , m_RenderWindowPart(nullptr)
   , m_MouseCursorSet(false)
   , m_DataSelectionChanged(false)
 {
   mitk::TNodePredicateDataType<mitk::Image>::Pointer isImage = mitk::TNodePredicateDataType<mitk::Image>::New();
   mitk::NodePredicateDataType::Pointer isDwi = mitk::NodePredicateDataType::New("DiffusionImage");
   mitk::NodePredicateDataType::Pointer isDti = mitk::NodePredicateDataType::New("TensorImage");
   mitk::NodePredicateDataType::Pointer isOdf = mitk::NodePredicateDataType::New("OdfImage");
   auto isSegment = mitk::NodePredicateDataType::New("Segment");
 
   mitk::NodePredicateOr::Pointer validImages = mitk::NodePredicateOr::New();
   validImages->AddPredicate(mitk::NodePredicateAnd::New(isImage, mitk::NodePredicateNot::New(isSegment)));
   validImages->AddPredicate(isDwi);
   validImages->AddPredicate(isDti);
   validImages->AddPredicate(isOdf);
 
   m_IsNotAHelperObject = mitk::NodePredicateNot::New(mitk::NodePredicateProperty::New("helper object", mitk::BoolProperty::New(true)));
 
   m_IsOfTypeImagePredicate = mitk::NodePredicateAnd::New(validImages, m_IsNotAHelperObject);
 
   mitk::NodePredicateProperty::Pointer isBinaryPredicate = mitk::NodePredicateProperty::New("binary", mitk::BoolProperty::New(true));
   mitk::NodePredicateNot::Pointer isNotBinaryPredicate = mitk::NodePredicateNot::New(isBinaryPredicate);
 
   mitk::NodePredicateAnd::Pointer isABinaryImagePredicate = mitk::NodePredicateAnd::New(m_IsOfTypeImagePredicate, isBinaryPredicate);
   mitk::NodePredicateAnd::Pointer isNotABinaryImagePredicate = mitk::NodePredicateAnd::New(m_IsOfTypeImagePredicate, isNotBinaryPredicate);
 
   m_IsASegmentationImagePredicate = mitk::NodePredicateOr::New(isABinaryImagePredicate, mitk::TNodePredicateDataType<mitk::LabelSetImage>::New());
   m_IsAPatientImagePredicate = mitk::NodePredicateAnd::New(isNotABinaryImagePredicate, mitk::NodePredicateNot::New(mitk::TNodePredicateDataType<mitk::LabelSetImage>::New()));
 }
 
 QmitkSegmentationView::~QmitkSegmentationView()
 {
   if (m_Controls)
   {
     SetToolSelectionBoxesEnabled(false);
     // deactivate all tools
     mitk::ToolManagerProvider::GetInstance()->GetToolManager()->ActivateTool(-1);
 
     // removing all observers
     for (NodeTagMapType::iterator dataIter = m_WorkingDataObserverTags.begin(); dataIter != m_WorkingDataObserverTags.end(); ++dataIter)
     {
       (*dataIter).first->GetProperty("visible")->RemoveObserver((*dataIter).second);
     }
     m_WorkingDataObserverTags.clear();
 
     mitk::RenderingManager::GetInstance()->RemoveObserver(m_RenderingManagerObserverTag);
 
     ctkPluginContext* context = mitk::PluginActivator::getContext();
     ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
     mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
     service->RemoveAllPlanePositions();
     context->ungetService(ppmRef);
     SetToolManagerSelection(nullptr, nullptr);
   }
 
   delete m_Controls;
 }
 
 void QmitkSegmentationView::NewNodeObjectsGenerated(mitk::ToolManager::DataVectorType* nodes)
 {
    if (!nodes) return;
 
    mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
    if (!toolManager) return;
    for (mitk::ToolManager::DataVectorType::iterator iter = nodes->begin(); iter != nodes->end(); ++iter)
    {
       this->FireNodeSelected( *iter );
       // only last iteration meaningful, multiple generated objects are not taken into account here
    }
 }
 
 void QmitkSegmentationView::RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart)
 {
   if (m_RenderWindowPart != renderWindowPart)
   {
     m_RenderWindowPart = renderWindowPart;
   }
 
   if (m_Parent)
   {
     m_Parent->setEnabled(true);
   }
 
   // tell the interpolation about tool manager, data storage and render window part
   if (m_Controls)
   {
     mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
     m_Controls->m_SlicesInterpolator->SetDataStorage(this->GetDataStorage());
     QList<mitk::SliceNavigationController*> controllers;
     controllers.push_back(renderWindowPart->GetQmitkRenderWindow("axial")->GetSliceNavigationController());
     controllers.push_back(renderWindowPart->GetQmitkRenderWindow("sagittal")->GetSliceNavigationController());
     controllers.push_back(renderWindowPart->GetQmitkRenderWindow("coronal")->GetSliceNavigationController());
     m_Controls->m_SlicesInterpolator->Initialize(toolManager, controllers);
   }
 }
 
 void QmitkSegmentationView::RenderWindowPartDeactivated(mitk::IRenderWindowPart* /*renderWindowPart*/)
 {
   m_RenderWindowPart = nullptr;
   if (m_Parent)
   {
     m_Parent->setEnabled(false);
   }
 }
 
 void QmitkSegmentationView::OnPreferencesChanged(const berry::IBerryPreferences* prefs)
 {
    if (m_Controls != nullptr)
    {
       bool slimView = prefs->GetBool("slim view", false);
       m_Controls->m_ManualToolSelectionBox2D->SetShowNames(!slimView);
       m_Controls->m_ManualToolSelectionBox3D->SetShowNames(!slimView);
       m_Controls->btnNewSegmentation->setToolButtonStyle(slimView
         ? Qt::ToolButtonIconOnly
         : Qt::ToolButtonTextOnly);
    }
 
    auto autoSelectionEnabled = prefs->GetBool("auto selection", true);
    m_Controls->patImageSelector->SetAutoSelectNewNodes(autoSelectionEnabled);
    m_Controls->segImageSelector->SetAutoSelectNewNodes(autoSelectionEnabled);
    this->ForceDisplayPreferencesUponAllImages();
 }
 
 void QmitkSegmentationView::CreateNewSegmentation()
 {
    mitk::DataNode::Pointer node = mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetReferenceData(0);
    if (node.IsNotNull())
    {
      mitk::Image::ConstPointer image = dynamic_cast<mitk::Image*>(node->GetData());
      if (image.IsNotNull())
      {
        if (image->GetDimension() > 1)
        {
          // ask about the name and organ type of the new segmentation
          QmitkNewSegmentationDialog* dialog = new QmitkNewSegmentationDialog(m_Parent); // needs a QWidget as parent, "this" is not QWidget
          QStringList organColors = mitk::OrganNamesHandling::GetDefaultOrganColorString();;
 
          dialog->SetSuggestionList(organColors);
 
          int dialogReturnValue = dialog->exec();
          if (dialogReturnValue == QDialog::Rejected)
          {
            // user clicked cancel or pressed Esc or something similar
            return;
          }
 
          if (image->GetDimension() > 3)
          {
            auto result = QMessageBox::question(m_Parent, tr("Generate a static mask?"),tr("The selected image has multiple time steps. You can either generate a simple/static masks resembling the geometry of the first timestep of the image. Or you can generate a dynamic mask that equals the selected image in geometry and number of timesteps; thus a dynamic mask can change over time (e.g. according to the image)."), tr("Yes, generate a static mask"), tr("No, generate a dynamic mask"), QString(), 0,0);
            if (result == 0)
            {
              auto selector = mitk::ImageTimeSelector::New();
              selector->SetInput(image);
              selector->SetTimeNr(0);
              selector->Update();
 
              const auto refTimeGeometry = image->GetTimeGeometry();
              auto newTimeGeometry = mitk::ProportionalTimeGeometry::New();
              newTimeGeometry->SetFirstTimePoint(refTimeGeometry->GetMinimumTimePoint());
              newTimeGeometry->SetStepDuration(refTimeGeometry->GetMaximumTimePoint() - refTimeGeometry->GetMinimumTimePoint());
 
              mitk::Image::Pointer newImage = selector->GetOutput();
              newTimeGeometry->SetTimeStepGeometry(image->GetGeometry(), 0);
              newImage->SetTimeGeometry(newTimeGeometry);
              image = newImage;
            }
          }
 
          // ask the user about an organ type and name, add this information to the image's (!) propertylist
          // create a new image of the same dimensions and smallest possible pixel type
          mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
          mitk::Tool* firstTool = toolManager->GetToolById(0);
          if (firstTool)
          {
            try
            {
              std::string newNodeName = dialog->GetSegmentationName().toStdString();
              if (newNodeName.empty())
              {
                newNodeName = "no_name";
              }
 
              mitk::DataNode::Pointer emptySegmentation = firstTool->CreateEmptySegmentationNode(image, newNodeName, dialog->GetColor());
              // initialize showVolume to false to prevent recalculating the volume while working on the segmentation
              emptySegmentation->SetProperty("showVolume", mitk::BoolProperty::New(false));
              if (!emptySegmentation)
              {
                return; // could be aborted by user
              }
 
              mitk::OrganNamesHandling::UpdateOrganList(organColors, dialog->GetSegmentationName(), dialog->GetColor());
 
              // escape ';' here (replace by '\;'), see longer comment above
              QString stringForStorage = organColors.replaceInStrings(";", "\\;").join(";");
              MITK_DEBUG << "Will store: " << stringForStorage;
              this->GetPreferences()->Put("Organ-Color-List", stringForStorage);
              this->GetPreferences()->Flush();
 
              if (mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetWorkingData(0))
              {
                mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetWorkingData(0)->SetSelected(false);
              }
              emptySegmentation->SetSelected(true);
              this->GetDataStorage()->Add(emptySegmentation, node); // add as a child, because the segmentation "derives" from the original
 
              m_Controls->segImageSelector->SetCurrentSelectedNode(emptySegmentation);
              mitk::RenderingManager::GetInstance()->InitializeViews(emptySegmentation->GetData()->GetTimeGeometry(), mitk::RenderingManager::REQUEST_UPDATE_ALL, true);
            }
            catch (const std::bad_alloc&)
            {
              QMessageBox::warning(nullptr, tr("Create new segmentation"), tr("Could not allocate memory for new segmentation"));
            }
          }
        }
        else
        {
          QMessageBox::information(nullptr, tr("Segmentation"), tr("Segmentation is currently not supported for 2D images"));
        }
      }
    }
    else
    {
      MITK_ERROR << "'Create new segmentation' button should never be clickable unless a patient image is selected...";
    }
 }
 
 void QmitkSegmentationView::OnVisiblePropertyChanged()
 {
    this->CheckRenderingState();
 }
 
 void QmitkSegmentationView::NodeAdded(const mitk::DataNode *node)
 {
   if (!m_IsASegmentationImagePredicate->CheckNode(node))
   {
     return;
   }
 
   itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
   command->SetCallbackFunction(this, &QmitkSegmentationView::OnVisiblePropertyChanged);
   m_WorkingDataObserverTags.insert(std::pair<mitk::DataNode*, unsigned long>(const_cast<mitk::DataNode*>(node), node->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command)));
 
   ApplyDisplayOptions(const_cast<mitk::DataNode*>(node));
 }
 
 void QmitkSegmentationView::NodeRemoved(const mitk::DataNode* node)
 {
   if (m_IsASegmentationImagePredicate->CheckNode(node))
   {
     //First of all remove all possible contour markers of the segmentation
     mitk::DataStorage::SetOfObjects::ConstPointer allContourMarkers = this->GetDataStorage()->GetDerivations(node, mitk::NodePredicateProperty::New("isContourMarker", mitk::BoolProperty::New(true)));
 
     ctkPluginContext* context = mitk::PluginActivator::getContext();
     ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
     mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
 
     for (mitk::DataStorage::SetOfObjects::ConstIterator it = allContourMarkers->Begin(); it != allContourMarkers->End(); ++it)
     {
       std::string nodeName = node->GetName();
       unsigned int t = nodeName.find_last_of(" ");
       unsigned int id = atof(nodeName.substr(t + 1).c_str()) - 1;
 
       service->RemovePlanePosition(id);
 
       this->GetDataStorage()->Remove(it->Value());
     }
 
     context->ungetService(ppmRef);
     service = nullptr;
 
     if ((mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetWorkingData(0) == node) && m_Controls->patImageSelector->GetSelectedNode().IsNotNull())
     {
       this->SetToolManagerSelection(mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetReferenceData(0), nullptr);
       this->UpdateWarningLabel(tr("Select or create a segmentation"));
     }
 
     mitk::Image* image = dynamic_cast<mitk::Image*>(node->GetData());
     mitk::SurfaceInterpolationController::GetInstance()->RemoveInterpolationSession(image);
   }
 
   mitk::DataNode* tempNode = const_cast<mitk::DataNode*>(node);
   //Remove observer if one was registered
   auto finding = m_WorkingDataObserverTags.find(tempNode);
   if (finding != m_WorkingDataObserverTags.end())
   {
     node->GetProperty("visible")->RemoveObserver(m_WorkingDataObserverTags[tempNode]);
     m_WorkingDataObserverTags.erase(tempNode);
   }
 }
 
 void QmitkSegmentationView::OnPatientSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
    if(! nodes.empty())
    {
       this->UpdateWarningLabel("");
       auto node = nodes.first();
 
-      auto geometryCheck = [node](const mitk::DataNode * segNode)
-      {
-        return QmitkSegmentationView::CheckForSameGeometry(segNode, node);
-      };
-      mitk::NodePredicateFunction::Pointer hasCorrectGeo = mitk::NodePredicateFunction::New(geometryCheck);
-      auto segPredicate = mitk::NodePredicateAnd::New(m_IsASegmentationImagePredicate.GetPointer(), hasCorrectGeo.GetPointer());
+      auto segPredicate = mitk::NodePredicateAnd::New(m_IsASegmentationImagePredicate.GetPointer(), mitk::NodePredicateSubGeometry::New(node->GetData()->GetGeometry()));
 
       m_Controls->segImageSelector->SetNodePredicate(segPredicate);
 
       mitk::DataNode* segNode = m_Controls->segImageSelector->GetSelectedNode();
       this->SetToolManagerSelection(node, segNode);
       if (segNode)
       {
         //Doing this we can assure that the segmentation is always visible if the segmentation and the patient image are
         //loaded separately
         int layer(10);
         node->GetIntProperty("layer", layer);
         layer++;
         segNode->SetProperty("layer", mitk::IntProperty::New(layer));
         this->CheckRenderingState();
       }
       else
       {
          this->SetToolSelectionBoxesEnabled( false );
          this->UpdateWarningLabel(tr("Select or create a segmentation"));
       }
    }
    else
    {
      m_Controls->segImageSelector->SetNodePredicate(m_IsASegmentationImagePredicate);
      this->UpdateWarningLabel(tr("Please select an image!"));
      this->SetToolSelectionBoxesEnabled( false );
    }
 }
 
 void QmitkSegmentationView::OnSegmentationSelectionChanged(QList<mitk::DataNode::Pointer> nodes)
 {
    if (nodes.empty())
    {
       this->UpdateWarningLabel(tr("Select or create a segmentation"));
       this->SetToolSelectionBoxesEnabled( false );
       return;
    }
 
    auto refNode = m_Controls->patImageSelector->GetSelectedNode();
    auto segNode = nodes.front();
 
    if (!refNode)
    {
      this->UpdateWarningLabel(tr("Please select the matching patient image!"));
      this->SetToolSelectionBoxesEnabled(false);
      this->SetToolManagerSelection(nullptr, segNode);
      return;
    }
 
    this->CheckRenderingState();
    if ( m_Controls->lblSegmentationWarnings->isVisible()) // "this->CheckRenderingState()" caused a warning. we do not need to go any further
       return;
 
    this->SetToolManagerSelection(refNode, segNode);
 
    if (segNode)
    {
      //Doing this we can assure that the segmenation is always visible if the segmentation and the patient image are
      //loaded separately
      int layer(10);
      refNode->GetIntProperty("layer", layer);
      layer++;
      segNode->SetProperty("layer", mitk::IntProperty::New(layer));
    }
    else
    {
      this->SetToolSelectionBoxesEnabled(false);
      this->UpdateWarningLabel(tr("Select or create a segmentation"));
    }
 
    mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart();
    if (!renderWindowPart || !segNode->IsVisible(renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer()))
    {
      this->UpdateWarningLabel(tr("The selected segmentation is currently not visible!"));
      this->SetToolSelectionBoxesEnabled( false );
    }
 }
 
 void QmitkSegmentationView::OnShowMarkerNodes (bool state)
 {
    mitk::SegTool2D::Pointer manualSegmentationTool;
 
    unsigned int numberOfExistingTools = mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetTools().size();
 
    for(unsigned int i = 0; i < numberOfExistingTools; i++)
    {
       manualSegmentationTool = dynamic_cast<mitk::SegTool2D*>(mitk::ToolManagerProvider::GetInstance()->GetToolManager()->GetToolById(i));
 
       if (manualSegmentationTool)
       {
          if(state == true)
          {
             manualSegmentationTool->SetShowMarkerNodes( true );
          }
          else
          {
             manualSegmentationTool->SetShowMarkerNodes( false );
          }
       }
    }
 }
 
 void QmitkSegmentationView::OnContourMarkerSelected(const mitk::DataNode *node)
 {
    QmitkRenderWindow* selectedRenderWindow = nullptr;
    QmitkRenderWindow* axialRenderWindow = GetRenderWindowPart(mitk::WorkbenchUtil::OPEN)->GetQmitkRenderWindow("axial");
    QmitkRenderWindow* sagittalRenderWindow = GetRenderWindowPart(mitk::WorkbenchUtil::OPEN)->GetQmitkRenderWindow("sagittal");
    QmitkRenderWindow* coronalRenderWindow = GetRenderWindowPart(mitk::WorkbenchUtil::OPEN)->GetQmitkRenderWindow("coronal");
    QmitkRenderWindow* _3DRenderWindow = GetRenderWindowPart(mitk::WorkbenchUtil::OPEN)->GetQmitkRenderWindow("3d");
    bool PlanarFigureInitializedWindow = false;
 
    // find initialized renderwindow
    if (node->GetBoolProperty("PlanarFigureInitializedWindow",
       PlanarFigureInitializedWindow, axialRenderWindow->GetRenderer()))
    {
       selectedRenderWindow = axialRenderWindow;
    }
    if (!selectedRenderWindow && node->GetBoolProperty(
       "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
       sagittalRenderWindow->GetRenderer()))
    {
       selectedRenderWindow = sagittalRenderWindow;
    }
    if (!selectedRenderWindow && node->GetBoolProperty(
       "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
       coronalRenderWindow->GetRenderer()))
    {
       selectedRenderWindow = coronalRenderWindow;
    }
    if (!selectedRenderWindow && node->GetBoolProperty(
       "PlanarFigureInitializedWindow", PlanarFigureInitializedWindow,
       _3DRenderWindow->GetRenderer()))
    {
       selectedRenderWindow = _3DRenderWindow;
    }
 
    // make node visible
    if (selectedRenderWindow)
    {
       std::string nodeName = node->GetName();
       unsigned int t = nodeName.find_last_of(" ");
       unsigned int id = atof(nodeName.substr(t+1).c_str())-1;
 
       {
          ctkPluginContext* context = mitk::PluginActivator::getContext();
          ctkServiceReference ppmRef = context->getServiceReference<mitk::PlanePositionManagerService>();
          mitk::PlanePositionManagerService* service = context->getService<mitk::PlanePositionManagerService>(ppmRef);
          selectedRenderWindow->GetSliceNavigationController()->ExecuteOperation(service->GetPlanePosition(id));
          context->ungetService(ppmRef);
       }
 
       selectedRenderWindow->GetRenderer()->GetCameraController()->Fit();
       mitk::RenderingManager::GetInstance()->RequestUpdateAll();
    }
 }
 
 void QmitkSegmentationView::OnSelectionChanged(berry::IWorkbenchPart::Pointer /*part*/, const QList<mitk::DataNode::Pointer> &nodes)
 {
   if (nodes.size() != 0)
   {
     std::string markerName = "Position";
     unsigned int numberOfNodes = nodes.size();
     std::string nodeName = nodes.at(0)->GetName();
     if ((numberOfNodes == 1) && (nodeName.find(markerName) == 0))
     {
       this->OnContourMarkerSelected(nodes.at(0));
       return;
     }
   }
 }
 
 void QmitkSegmentationView::OnTabWidgetChanged(int id)
 {
    //always disable tools on tab changed
    mitk::ToolManagerProvider::GetInstance()->GetToolManager()->ActivateTool(-1);
 
    //2D Tab ID = 0
    //3D Tab ID = 1
    if (id == 0)
    {
       //Hide 3D selection box, show 2D selection box
       m_Controls->m_ManualToolSelectionBox3D->hide();
       m_Controls->m_ManualToolSelectionBox2D->show();
       //Deactivate possible active tool
 
       //TODO Remove possible visible interpolations -> Maybe changes in SlicesInterpolator
    }
    else
    {
       //Hide 3D selection box, show 2D selection box
       m_Controls->m_ManualToolSelectionBox2D->hide();
       m_Controls->m_ManualToolSelectionBox3D->show();
       //Deactivate possible active tool
    }
 }
 
 void QmitkSegmentationView::SetToolManagerSelection(mitk::DataNode* referenceData, mitk::DataNode* workingData)
 {
   // called as a result of new BlueBerry selections
   //   tells the ToolManager for manual segmentation about new selections
   //   updates GUI information about what the user should select
   mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
   toolManager->SetReferenceData(const_cast<mitk::DataNode*>(referenceData));
   toolManager->SetWorkingData(const_cast<mitk::DataNode*>(workingData));
 
   m_Controls->btnNewSegmentation->setEnabled(referenceData != nullptr);
 }
 
 void QmitkSegmentationView::ForceDisplayPreferencesUponAllImages()
 {
    if (!m_Parent)
    {
      return;
    }
 
    // check all images and segmentations in DataStorage:
    // (items in brackets are implicitly done by previous steps)
    // 1.
    //   if  a reference image is selected,
    //     show the reference image
    //     and hide all other images (orignal and segmentation),
    //     (and hide all segmentations of the other original images)
    //     and show all the reference's segmentations
    //   if no reference image is selected, do do nothing
    //
    // 2.
    //   if  a segmentation is selected,
    //     show it
    //     (and hide all all its siblings (childs of the same parent, incl, nullptr parent))
    //   if no segmentation is selected, do nothing
 
    if (!m_Controls)
    {
      return; // might happen on initialization (preferences loaded)
    }
 
    mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
    mitk::DataNode::Pointer referenceData = toolManager->GetReferenceData(0);
    mitk::DataNode::Pointer workingData =   toolManager->GetWorkingData(0);
 
    // 1.
    if (referenceData.IsNotNull())
    {
       // iterate all images
      mitk::DataStorage::SetOfObjects::ConstPointer allImages = this->GetDataStorage()->GetSubset(m_IsASegmentationImagePredicate);
 
       for ( mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin(); iter != allImages->end(); ++iter)
 
       {
          mitk::DataNode* node = *iter;
          // apply display preferences
          ApplyDisplayOptions(node);
 
          // set visibility
          node->SetVisibility(node == referenceData);
       }
    }
 
    // 2.
    if (workingData.IsNotNull())
       workingData->SetVisibility(true);
 
    mitk::RenderingManager::GetInstance()->RequestUpdateAll();
 }
 
 void QmitkSegmentationView::ApplyDisplayOptions(mitk::DataNode* node)
 {
   if (!node)
   {
     return;
   }
 
   mitk::BoolProperty::Pointer drawOutline = mitk::BoolProperty::New(GetPreferences()->GetBool("draw outline", true));
   mitk::BoolProperty::Pointer volumeRendering = mitk::BoolProperty::New(GetPreferences()->GetBool("volume rendering", false));
   mitk::LabelSetImage* labelSetImage = dynamic_cast<mitk::LabelSetImage*>(node->GetData());
   if (nullptr != labelSetImage)
   {
     // node is actually a multi label segmentation,
     // but its outline property can be set in the 'single label' segmentation preference page as well
     node->SetProperty("labelset.contour.active", drawOutline);
     //node->SetProperty("opacity", mitk::FloatProperty::New(drawOutline->GetValue() ? 1.0f : 0.3f));
     node->SetProperty("volumerendering", volumeRendering);
     // force render window update to show outline
     node->GetData()->Modified();
   }
   else
   {
     // node is a 'single label' segmentation
     bool isBinary = false;
     node->GetBoolProperty("binary", isBinary);
     if (isBinary)
     {
       node->SetProperty("outline binary", drawOutline);
       node->SetProperty("outline width", mitk::FloatProperty::New(2.0));
       //node->SetProperty("opacity", mitk::FloatProperty::New(drawOutline->GetValue() ? 1.0f : 0.3f));
       node->SetProperty("volumerendering", volumeRendering);
       // force render window update to show outline
       node->GetData()->Modified();
     }
   }
 }
 
 void QmitkSegmentationView::CheckRenderingState()
 {
   mitk::IRenderWindowPart* renderWindowPart = this->GetRenderWindowPart();
   mitk::DataNode* workingNode = m_Controls->segImageSelector->GetSelectedNode();
 
   if (!workingNode)
   {
     this->SetToolSelectionBoxesEnabled(false);
     this->UpdateWarningLabel(tr("Select or create a segmentation"));
     return;
   }
 
   bool selectedNodeIsVisible = renderWindowPart && workingNode->IsVisible(renderWindowPart->GetQmitkRenderWindow("axial")->GetRenderer());
 
   if (!selectedNodeIsVisible)
   {
     this->SetToolSelectionBoxesEnabled(false);
     this->UpdateWarningLabel(tr("The selected segmentation is currently not visible!"));
     return;
   }
 
    /*
    * Here we check whether the geometry of the selected segmentation image if aligned with the worldgeometry
    * At the moment it is not supported to use a geometry different from the selected image for reslicing.
    * For further information see Bug 16063
    */
 
    const mitk::BaseGeometry* worldGeo = this->GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetSliceNavigationController()->GetCurrentGeometry3D();
 
    if (workingNode && worldGeo)
    {
 
       const mitk::BaseGeometry* workingNodeGeo = workingNode->GetData()->GetGeometry();
       const mitk::BaseGeometry* worldGeo = this->GetRenderWindowPart()->GetQmitkRenderWindow("3d")->GetSliceNavigationController()->GetCurrentGeometry3D();
 
       if (mitk::Equal(*workingNodeGeo->GetBoundingBox(), *worldGeo->GetBoundingBox(), mitk::eps, true))
       {
          this->SetToolManagerSelection(m_Controls->patImageSelector->GetSelectedNode(), workingNode);
          this->SetToolSelectionBoxesEnabled(true);
          this->UpdateWarningLabel("");
          return;
       }
    }
 
    this->SetToolManagerSelection(m_Controls->patImageSelector->GetSelectedNode(), nullptr);
    this->SetToolSelectionBoxesEnabled(false);
    this->UpdateWarningLabel(tr("Please perform a reinit on the segmentation image!"));
 }
 
-bool QmitkSegmentationView::CheckForSameGeometry(const mitk::DataNode *node1, const mitk::DataNode *node2)
-{
-   bool isSameGeometry(true);
-
-   mitk::Image* image1 = dynamic_cast<mitk::Image*>(node1->GetData());
-   mitk::Image* image2 = dynamic_cast<mitk::Image*>(node2->GetData());
-   if (image1 && image2)
-   {
-      mitk::BaseGeometry* geo1 = image1->GetGeometry();
-      mitk::BaseGeometry* geo2 = image2->GetGeometry();
-
-      isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetOrigin(), geo2->GetOrigin());
-      isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(0), geo2->GetExtent(0));
-      isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(1), geo2->GetExtent(1));
-      isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetExtent(2), geo2->GetExtent(2));
-      isSameGeometry = isSameGeometry && mitk::Equal(geo1->GetSpacing(), geo2->GetSpacing());
-      isSameGeometry = isSameGeometry && mitk::MatrixEqualElementWise(geo1->GetIndexToWorldTransform()->GetMatrix(), geo2->GetIndexToWorldTransform()->GetMatrix());
-
-      return isSameGeometry;
-   }
-   else
-   {
-      return false;
-   }
-}
-
 void QmitkSegmentationView::UpdateWarningLabel(QString text)
 {
    if (text.size() == 0)
       m_Controls->lblSegmentationWarnings->hide();
    else
       m_Controls->lblSegmentationWarnings->show();
    m_Controls->lblSegmentationWarnings->setText("<font color=\"red\">" + text + "</font>");
 }
 
 void QmitkSegmentationView::CreateQtPartControl(QWidget* parent)
 {
    // setup the basic GUI of this view
    m_Parent = parent;
 
    m_Controls = new Ui::QmitkSegmentationControls;
    m_Controls->setupUi(parent);
 
    m_Controls->patImageSelector->SetDataStorage(GetDataStorage());
    m_Controls->patImageSelector->SetNodePredicate(m_IsAPatientImagePredicate);
    m_Controls->patImageSelector->SetSelectionIsOptional(false);
    m_Controls->patImageSelector->SetInvalidInfo("Select an image.");
    m_Controls->patImageSelector->SetPopUpTitel("Select an image.");
    m_Controls->patImageSelector->SetPopUpHint("Select an image that should be used to define the geometry and bounds of the segmentation.");
 
    UpdateWarningLabel(tr("Please select an image"));
 
    if (m_Controls->patImageSelector->GetSelectedNode().IsNotNull())
    {
      UpdateWarningLabel(tr("Select or create a new segmentation"));
    }
 
    m_Controls->segImageSelector->SetDataStorage(GetDataStorage());
    m_Controls->segImageSelector->SetNodePredicate(m_IsASegmentationImagePredicate);
    m_Controls->segImageSelector->SetSelectionIsOptional(false);
    m_Controls->segImageSelector->SetInvalidInfo("Select a segmentation.");
    m_Controls->segImageSelector->SetPopUpTitel("Select a segmentation.");
    m_Controls->segImageSelector->SetPopUpHint("Select a segmentation that should be modified. Only segmentation with the same geometry and within the bounds of the reference image are selected.");
 
    if (m_Controls->segImageSelector->GetSelectedNode().IsNotNull())
    {
      UpdateWarningLabel("");
    }
 
    mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
    assert(toolManager);
 
    toolManager->SetDataStorage(*(GetDataStorage()));
    toolManager->InitializeTools();
 
    QString segTools2D = tr("Add Subtract Correction Paint Wipe 'Region Growing' Fill Erase 'Live Wire' '2D Fast Marching'");
    QString segTools3D = tr("Threshold 'UL Threshold' Otsu 'Fast Marching 3D' 'Region Growing 3D' Watershed Picking");
 
    std::regex extSegTool2DRegEx("SegTool2D$");
    std::regex extSegTool3DRegEx("SegTool3D$");
 
    auto tools = toolManager->GetTools();
 
    for (const auto &tool : tools)
    {
      if (std::regex_search(tool->GetNameOfClass(), extSegTool2DRegEx))
      {
        segTools2D.append(QString(" '%1'").arg(tool->GetName()));
      }
      else if (std::regex_search(tool->GetNameOfClass(), extSegTool3DRegEx))
      {
        segTools3D.append(QString(" '%1'").arg(tool->GetName()));
      }
    }
 
    // all part of open source MITK
    m_Controls->m_ManualToolSelectionBox2D->setEnabled(true);
    m_Controls->m_ManualToolSelectionBox2D->SetGenerateAccelerators(true);
    m_Controls->m_ManualToolSelectionBox2D->SetToolGUIArea(m_Controls->m_ManualToolGUIContainer2D);
 
    m_Controls->m_ManualToolSelectionBox2D->SetDisplayedToolGroups(segTools2D.toStdString());
    m_Controls->m_ManualToolSelectionBox2D->SetLayoutColumns(3);
    m_Controls->m_ManualToolSelectionBox2D->SetEnabledMode(QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
    connect(m_Controls->m_ManualToolSelectionBox2D, &QmitkToolSelectionBox::ToolSelected, this, &QmitkSegmentationView::OnManualTool2DSelected);
 
    //setup 3D Tools
    m_Controls->m_ManualToolSelectionBox3D->setEnabled(true);
    m_Controls->m_ManualToolSelectionBox3D->SetGenerateAccelerators(true);
    m_Controls->m_ManualToolSelectionBox3D->SetToolGUIArea(m_Controls->m_ManualToolGUIContainer3D);
    //specify tools to be added to 3D Tool area
    m_Controls->m_ManualToolSelectionBox3D->SetDisplayedToolGroups(segTools3D.toStdString());
    m_Controls->m_ManualToolSelectionBox3D->SetLayoutColumns(3);
    m_Controls->m_ManualToolSelectionBox3D->SetEnabledMode(QmitkToolSelectionBox::EnabledWithReferenceAndWorkingDataVisible);
 
    //Hide 3D selection box, show 2D selection box
    m_Controls->m_ManualToolSelectionBox3D->hide();
    m_Controls->m_ManualToolSelectionBox2D->show();
 
    // update the list of segmentations
    toolManager->NewNodeObjectsGenerated += mitk::MessageDelegate1<QmitkSegmentationView, mitk::ToolManager::DataVectorType*>(this, &QmitkSegmentationView::NewNodeObjectsGenerated);
 
    // create signal/slot connections
    connect(m_Controls->patImageSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkSegmentationView::OnPatientSelectionChanged);
    connect(m_Controls->segImageSelector, &QmitkAbstractNodeSelectionWidget::CurrentSelectionChanged, this, &QmitkSegmentationView::OnSegmentationSelectionChanged);
 
    connect(m_Controls->btnNewSegmentation, &QToolButton::clicked, this, &QmitkSegmentationView::CreateNewSegmentation);
    connect(m_Controls->tabWidgetSegmentationTools, &QTabWidget::currentChanged, this, &QmitkSegmentationView::OnTabWidgetChanged);
    connect(m_Controls->m_SlicesInterpolator, &QmitkSlicesInterpolator::SignalShowMarkerNodes, this, &QmitkSegmentationView::OnShowMarkerNodes);
 
    // set callback function for already existing nodes (images & segmentations)
    mitk::DataStorage::SetOfObjects::ConstPointer allImages = GetDataStorage()->GetSubset(m_IsOfTypeImagePredicate);
    for (mitk::DataStorage::SetOfObjects::const_iterator iter = allImages->begin(); iter != allImages->end(); ++iter)
    {
      mitk::DataNode* node = *iter;
      itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
      command->SetCallbackFunction(this, &QmitkSegmentationView::OnVisiblePropertyChanged);
      m_WorkingDataObserverTags.insert(std::pair<mitk::DataNode*, unsigned long>(node, node->GetProperty("visible")->AddObserver(itk::ModifiedEvent(), command)));
    }
 
    itk::SimpleMemberCommand<QmitkSegmentationView>::Pointer command = itk::SimpleMemberCommand<QmitkSegmentationView>::New();
    command->SetCallbackFunction(this, &QmitkSegmentationView::CheckRenderingState);
    m_RenderingManagerObserverTag = mitk::RenderingManager::GetInstance()->AddObserver(mitk::RenderingManagerViewsInitializedEvent(), command);
 
    SetToolManagerSelection(m_Controls->patImageSelector->GetSelectedNode(), m_Controls->segImageSelector->GetSelectedNode());
 
    m_RenderWindowPart = GetRenderWindowPart();
    if (m_RenderWindowPart)
    {
      RenderWindowPartActivated(m_RenderWindowPart);
    }
 
    //Should be done last, if everything else is configured because it triggers the autoselection of data.
    m_Controls->patImageSelector->SetAutoSelectNewNodes(true);
    m_Controls->segImageSelector->SetAutoSelectNewNodes(true);
 }
 
 void QmitkSegmentationView::SetFocus()
 {
   m_Controls->btnNewSegmentation->setFocus();
 }
 
 void QmitkSegmentationView::OnManualTool2DSelected(int id)
 {
    if (id >= 0)
    {
       std::string text = "Active Tool: \"";
       mitk::ToolManager* toolManager = mitk::ToolManagerProvider::GetInstance()->GetToolManager();
       text += toolManager->GetToolById(id)->GetName();
       text += "\"";
       mitk::StatusBar::GetInstance()->DisplayText(text.c_str());
 
       us::ModuleResource resource = toolManager->GetToolById(id)->GetCursorIconResource();
       this->SetMouseCursor(resource, 0, 0);
    }
    else
    {
       this->ResetMouseCursor();
       mitk::StatusBar::GetInstance()->DisplayText("");
    }
 }
 
 void QmitkSegmentationView::ResetMouseCursor()
 {
    if ( m_MouseCursorSet )
    {
       mitk::ApplicationCursor::GetInstance()->PopCursor();
       m_MouseCursorSet = false;
    }
 }
 
 void QmitkSegmentationView::SetMouseCursor( const us::ModuleResource& resource, int hotspotX, int hotspotY )
 {
    // Remove previously set mouse cursor
    if (m_MouseCursorSet)
       this->ResetMouseCursor();
 
    if (resource)
    {
      us::ModuleResourceStream cursor(resource, std::ios::binary);
      mitk::ApplicationCursor::GetInstance()->PushCursor(cursor, hotspotX, hotspotY);
      m_MouseCursorSet = true;
    }
 }
 
 void QmitkSegmentationView::SetToolSelectionBoxesEnabled(bool status)
 {
   if (status)
   {
     m_Controls->m_ManualToolSelectionBox2D->RecreateButtons();
     m_Controls->m_ManualToolSelectionBox3D->RecreateButtons();
   }
 
   m_Controls->m_ManualToolSelectionBox2D->setEnabled(status);
   m_Controls->m_ManualToolSelectionBox3D->setEnabled(status);
   m_Controls->m_SlicesInterpolator->setEnabled(status);
 }
diff --git a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h
index 0fb6d60c43..3ea9d5b5dc 100644
--- a/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h
+++ b/Plugins/org.mitk.gui.qt.segmentation/src/internal/QmitkSegmentationView.h
@@ -1,135 +1,133 @@
 /*============================================================================
 
 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 QMITKSEGMENTATIONVIEW_H
 #define QMITKSEGMENTATIONVIEW_H
 
 #include <QmitkAbstractView.h>
 #include <mitkILifecycleAwarePart.h>
 #include <mitkIRenderWindowPartListener.h>
 
 #include <berryIBerryPreferences.h>
 
 #include "ui_QmitkSegmentationControls.h"
 
 class QmitkRenderWindow;
 
 /**
 * @brief
 *
 *
 */
 class QmitkSegmentationView : public QmitkAbstractView, public mitk::IRenderWindowPartListener
 {
   Q_OBJECT
 
 public:
 
   QmitkSegmentationView();
 
   ~QmitkSegmentationView() override;
 
   typedef std::map<mitk::DataNode*, unsigned long> NodeTagMapType;
 
   void NewNodeObjectsGenerated(mitk::ToolManager::DataVectorType*);
 
   void SetFocus() override;
 
   void RenderWindowPartActivated(mitk::IRenderWindowPart* renderWindowPart) override;
 
   void RenderWindowPartDeactivated(mitk::IRenderWindowPart* renderWindowPart) override;
 
   // BlueBerry's notification about preference changes (e.g. from a dialog)
   void OnPreferencesChanged(const berry::IBerryPreferences* prefs) override;
 
   // observer to mitk::RenderingManager's RenderingManagerViewsInitializedEvent event
   void CheckRenderingState();
 
   static const std::string VIEW_ID;
 
   protected slots:
 
   void OnPatientSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
   void OnSegmentationSelectionChanged(QList<mitk::DataNode::Pointer> nodes);
 
   // reaction to the button "New segmentation"
   void CreateNewSegmentation();
 
   void OnManualTool2DSelected(int id);
 
   void OnVisiblePropertyChanged();
 
   void OnShowMarkerNodes(bool);
 
   void OnTabWidgetChanged(int);
 
 protected:
 
   // a type for handling lists of DataNodes
   typedef std::vector<mitk::DataNode*> NodeList;
 
   // GUI setup
   void CreateQtPartControl(QWidget* parent) override;
 
   // propagate BlueBerry selection to ToolManager for manual segmentation
   void SetToolManagerSelection(mitk::DataNode* referenceData, mitk::DataNode* workingData);
 
   // make sure all images/segmentations look as selected by the users in this view's preferences
   void ForceDisplayPreferencesUponAllImages();
 
   // decorates a DataNode according to the user preference settings
   void ApplyDisplayOptions(mitk::DataNode* node);
 
   void ResetMouseCursor();
 
   void SetMouseCursor(const us::ModuleResource&, int hotspotX, int hotspotY);
 
   void SetToolSelectionBoxesEnabled(bool);
 
   // If a contourmarker is selected, the plane in the related widget will be reoriented according to the marker`s geometry
   void OnContourMarkerSelected(const mitk::DataNode* node);
 
   void OnSelectionChanged(berry::IWorkbenchPart::Pointer part, const QList<mitk::DataNode::Pointer> &nodes) override;
 
   void NodeRemoved(const mitk::DataNode* node) override;
 
   void NodeAdded(const mitk::DataNode *node) override;
 
-  static bool CheckForSameGeometry(const mitk::DataNode*, const mitk::DataNode*);
-
   void UpdateWarningLabel(QString text/*, bool overwriteExistingText = true*/);
 
   // the Qt parent of our GUI (NOT of this object)
   QWidget* m_Parent;
 
   // our GUI
   Ui::QmitkSegmentationControls* m_Controls;
 
   mitk::IRenderWindowPart* m_RenderWindowPart;
 
   unsigned long m_VisibilityChangedObserverTag;
 
   bool m_MouseCursorSet;
 
   bool m_DataSelectionChanged;
 
   NodeTagMapType  m_WorkingDataObserverTags;
 
   unsigned int m_RenderingManagerObserverTag;
 
   mitk::NodePredicateNot::Pointer m_IsNotAHelperObject;
   mitk::NodePredicateAnd::Pointer m_IsOfTypeImagePredicate;
   mitk::NodePredicateOr::Pointer m_IsASegmentationImagePredicate;
   mitk::NodePredicateAnd::Pointer m_IsAPatientImagePredicate;
 };
 
 #endif // QMITKSEGMENTATIONVIEW_H