diff --git a/Modules/Core/files.cmake b/Modules/Core/files.cmake
index 0cf484a956..12fa8bb201 100644
--- a/Modules/Core/files.cmake
+++ b/Modules/Core/files.cmake
@@ -1,318 +1,319 @@
 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/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
 
   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/mitkIIdentifiable.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/mitkNodePredicateUID.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/mitkPropertyList.cpp
   DataManagement/mitkPropertyListReplacedObserver.cpp
   DataManagement/mitkPropertyNameHelper.cpp
   DataManagement/mitkPropertyObserver.cpp
   DataManagement/mitkPropertyPersistence.cpp
   DataManagement/mitkPropertyPersistenceInfo.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/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
 
   Interactions/mitkAction.cpp
   Interactions/mitkBindDispatcherInteractor.cpp
   Interactions/mitkCrosshairPositionEvent.cpp
   Interactions/mitkDataInteractor.cpp
   Interactions/mitkDispatcher.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/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/mitkDicomSeriesReader.cpp
   IO/mitkDicomSeriesReaderService.cpp
   IO/mitkDicomSR_GantryTiltInformation.cpp
   IO/mitkDicomSR_ImageBlockDescriptor.cpp
   IO/mitkDicomSR_LoadDICOMRGBPixel4D.cpp
   IO/mitkDicomSR_LoadDICOMRGBPixel.cpp
   IO/mitkDicomSR_LoadDICOMScalar4D.cpp
   IO/mitkDicomSR_LoadDICOMScalar.cpp
   IO/mitkDicomSR_SliceGroupingResult.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
 
   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/mitkBaseData.h b/Modules/Core/include/mitkBaseData.h
index da1331b991..d6f6257c2e 100644
--- a/Modules/Core/include/mitkBaseData.h
+++ b/Modules/Core/include/mitkBaseData.h
@@ -1,423 +1,420 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef BASEDATA_H_HEADER_INCLUDED_C1EBB6FA
 #define BASEDATA_H_HEADER_INCLUDED_C1EBB6FA
 
 #include <itkDataObject.h>
 
 #include "mitkBaseProcess.h"
-#include "mitkIIdentifiable.h"
+#include "mitkIdentifiable.h"
 #include "mitkIPropertyOwner.h"
 #include "mitkOperationActor.h"
 #include "mitkPropertyList.h"
 #include "mitkTimeGeometry.h"
 #include <MitkCoreExports.h>
 
 namespace mitk
 {
   // class BaseProcess;
 
   //##Documentation
   //## @brief Base of all data objects
   //##
   //## Base of all data objects, e.g., images, contours, surfaces etc. Inherits
   //## from itk::DataObject and thus can be included in a pipeline.
   //## Inherits also from OperationActor and can be used as a destination for Undo
   //## @ingroup Data
   class MITKCORE_EXPORT BaseData
-    : public itk::DataObject, public OperationActor, public IIdentifiable, public IPropertyOwner
+    : public itk::DataObject, public OperationActor, public Identifiable, public IPropertyOwner
   {
   public:
     mitkClassMacroItkParent(BaseData, itk::DataObject)
 
-    // IIdentifiable
-    virtual UIDType GetUID() const override;
-
     // IPropertyProvider
-    virtual BaseProperty::ConstPointer GetConstProperty(const std::string &propertyName, const std::string &contextName = "", bool fallBackOnDefaultContext = true) const override;
-    virtual std::vector<std::string> GetPropertyNames(const std::string &contextName = "", bool includeDefaultContext = false) const override;
+    virtual BaseProperty::ConstPointer GetConstProperty(const std::string &propertyKey, const std::string &contextName = "", bool fallBackOnDefaultContext = true) const override;
+    virtual std::vector<std::string> GetPropertyKeys(const std::string &contextName = "", bool includeDefaultContext = false) const override;
     virtual std::vector<std::string> GetPropertyContextNames() const override;
 
     // IPropertyOwner
-    virtual BaseProperty * GetNonConstProperty(const std::string &propertyName, const std::string &contextName = "", bool fallBackOnDefaultContext = true) override;
-    virtual void SetProperty(const std::string &propertyName, BaseProperty *property, const std::string &contextName = "", bool fallBackOnDefaultContext = false) override;
+    virtual BaseProperty * GetNonConstProperty(const std::string &propertyKey, const std::string &contextName = "", bool fallBackOnDefaultContext = true) override;
+    virtual void SetProperty(const std::string &propertyKey, BaseProperty *property, const std::string &contextName = "", bool fallBackOnDefaultContext = false) override;
 
     /**
     * \brief Return the TimeGeometry of the data as const pointer.
     *
     * \warning No update will be called. Use GetUpdatedGeometry() if you cannot
     * be sure that the geometry is up-to-date.
     *
     * Normally used in GenerateOutputInformation of subclasses of BaseProcess.
     */
     const mitk::TimeGeometry *GetTimeGeometry() const
     {
       return m_TimeGeometry.GetPointer();
     }
 
     /**
     * \brief Return the TimeGeometry of the data as const pointer.
     *
     * \warning No update will be called. Use GetUpdatedGeometry() if you cannot
     * be sure that the geometry is up-to-date.
     *
     * Normally used in GenerateOutputInformation of subclasses of BaseProcess.
      * \deprecatedSince{2013_09} Please use GetTimeGeometry instead: For additional information see
     * http://www.mitk.org/Development/Refactoring%20of%20the%20Geometry%20Classes%20-%20Part%201
     */
     DEPRECATED(const mitk::TimeGeometry *GetTimeSlicedGeometry() const) { return GetTimeGeometry(); }
     /**
     * @brief Return the TimeGeometry of the data as pointer.
     *
     * \warning No update will be called. Use GetUpdatedGeometry() if you cannot
     * be sure that the geometry is up-to-date.
     *
     * Normally used in GenerateOutputInformation of subclasses of BaseProcess.
     */
     mitk::TimeGeometry *GetTimeGeometry() { return m_TimeGeometry.GetPointer(); }
     /**
     * @brief Return the TimeGeometry of the data.
     *
     * The method does not simply return the value of the m_TimeGeometry
     * member. Before doing this, it makes sure that the TimeGeometry
     * is up-to-date (by setting the update extent to largest possible and
     * calling UpdateOutputInformation).
     */
     const mitk::TimeGeometry *GetUpdatedTimeGeometry();
 
     /**
     * @brief Return the TimeGeometry of the data.
     *
     * The method does not simply return the value of the m_TimeGeometry
     * member. Before doing this, it makes sure that the TimeGeometry
     * is up-to-date (by setting the update extent to largest possible and
     * calling UpdateOutputInformation).
     * \deprecatedSince{2013_09} Please use GetUpdatedTimeGeometry instead: For additional information see
     * http://www.mitk.org/Development/Refactoring%20of%20the%20Geometry%20Classes%20-%20Part%201
     */
     DEPRECATED(const mitk::TimeGeometry *GetUpdatedTimeSliceGeometry()) { return GetUpdatedTimeGeometry(); }
     /**
     * \brief Expands the TimeGeometry to a number of TimeSteps.
     *
     * The method expands the TimeGeometry to the given number of TimeSteps,
     * filling newly created elements with empty geometries. Sub-classes should override
     * this method to handle the elongation of their data vectors, too.
     * Note that a shrinking is neither possible nor intended.
     */
     virtual void Expand(unsigned int timeSteps);
 
     /**
     * \brief Return the BaseGeometry of the data at time \a t.
     *
     * The method does not simply return
     * m_TimeGeometry->GetGeometry(t).
     * Before doing this, it makes sure that the BaseGeometry is up-to-date
     * (by setting the update extent appropriately and calling
     * UpdateOutputInformation).
     *
     * @todo Appropriate setting of the update extent is missing.
     */
     const mitk::BaseGeometry *GetUpdatedGeometry(int t = 0);
 
     //##Documentation
     //## @brief Return the geometry, which is a TimeGeometry, of the data
     //## as non-const pointer.
     //##
     //## \warning No update will be called. Use GetUpdatedGeometry() if you cannot
     //## be sure that the geometry is up-to-date.
     //##
     //## Normally used in GenerateOutputInformation of subclasses of BaseProcess.
     mitk::BaseGeometry *GetGeometry(int t = 0) const
     {
       if (m_TimeGeometry.IsNull())
         return nullptr;
       return m_TimeGeometry->GetGeometryForTimeStep(t);
     }
 
     //##Documentation
     //## @brief Update the information for this BaseData (the geometry in particular)
     //## so that it can be used as an output of a BaseProcess.
     //##
     //## This method is used in the pipeline mechanism to propagate information and
     //## initialize the meta data associated with a BaseData. Any implementation
     //## of this method in a derived class is assumed to call its source's
     //## BaseProcess::UpdateOutputInformation() which determines modified
     //## times, LargestPossibleRegions, and any extra meta data like spacing,
     //## origin, etc. Default implementation simply call's it's source's
     //## UpdateOutputInformation().
     //## \note Implementations of this methods in derived classes must take care
     //## that the geometry is updated by calling
     //## GetTimeGeometry()->UpdateInformation()
     //## \em after calling its source's BaseProcess::UpdateOutputInformation().
     void UpdateOutputInformation() override;
 
     //##Documentation
     //## @brief Set the RequestedRegion to the LargestPossibleRegion.
     //##
     //## This forces a filter to produce all of the output in one execution
     //## (i.e. not streaming) on the next call to Update().
     virtual void SetRequestedRegionToLargestPossibleRegion() override = 0;
 
     //##Documentation
     //## @brief Determine whether the RequestedRegion is outside of the BufferedRegion.
     //##
     //## This method returns true if the RequestedRegion
     //## is outside the BufferedRegion (true if at least one pixel is
     //## outside). This is used by the pipeline mechanism to determine
     //## whether a filter needs to re-execute in order to satisfy the
     //## current request.  If the current RequestedRegion is already
     //## inside the BufferedRegion from the previous execution (and the
     //## current filter is up to date), then a given filter does not need
     //## to re-execute
     virtual bool RequestedRegionIsOutsideOfTheBufferedRegion() override = 0;
 
     //##Documentation
     //## @brief Verify that the RequestedRegion is within the LargestPossibleRegion.
     //##
     //## If the RequestedRegion is not within the LargestPossibleRegion,
     //## then the filter cannot possibly satisfy the request. This method
     //## returns true if the request can be satisfied (even if it will be
     //## necessary to process the entire LargestPossibleRegion) and
     //## returns false otherwise.  This method is used by
     //## PropagateRequestedRegion().  PropagateRequestedRegion() throws a
     //## InvalidRequestedRegionError exception if the requested region is
     //## not within the LargestPossibleRegion.
     virtual bool VerifyRequestedRegion() override = 0;
 
     //##Documentation
     //## @brief Copy information from the specified data set.
     //##
     //## This method is part of the pipeline execution model. By default, a
     //## BaseProcess will copy meta-data from the first input to all of its
     //## outputs. See ProcessObject::GenerateOutputInformation().  Each
     //## subclass of DataObject is responsible for being able to copy
     //## whatever meta-data it needs from another DataObject.
     //## The default implementation of this method copies the time sliced geometry
     //## and the property list of an object. If a subclass overrides this
     //## method, it should always call its superclass' version.
     void CopyInformation(const itk::DataObject *data) override;
 
     //##Documentation
     //## @brief Check whether the data has been initialized, i.e.,
     //## at least the Geometry and other header data has been set
     //##
     //## \warning Set to \a true by default for compatibility reasons.
     //## Set m_Initialized=false in constructors of sub-classes that
     //## support distinction between initialized and uninitialized state.
     virtual bool IsInitialized() const;
 
     //##Documentation
     //## @brief Calls ClearData() and InitializeEmpty();
     //## \warning Only use in subclasses that reimplemented these methods.
     //## Just calling Clear from BaseData will reset an object to a not initialized,
     //## invalid state.
     virtual void Clear();
 
     //##Documentation
     //## @brief Check whether object contains data (at
     //## a specified time), e.g., a set of points may be empty
     //##
     //## \warning Returns IsInitialized()==false by default for
     //## compatibility reasons. Override in sub-classes that
     //## support distinction between empty/non-empty state.
     virtual bool IsEmptyTimeStep(unsigned int t) const;
 
     //##Documentation
     //## @brief Check whether object contains data (at
     //## least at one point in time), e.g., a set of points
     //## may be empty
     //##
     //## \warning Returns IsInitialized()==false by default for
     //## compatibility reasons. Override in sub-classes that
     //## support distinction between empty/non-empty state.
     virtual bool IsEmpty() const;
 
     //##Documentation
     //## @brief Set the requested region from this data object to match the requested
     //## region of the data object passed in as a parameter.
     //##
     //## This method is implemented in the concrete subclasses of BaseData.
     virtual void SetRequestedRegion(const itk::DataObject *data) override = 0;
 
     //##Documentation
     //##@brief overwrite if the Data can be called by an Interactor (StateMachine).
     //##
     //## Empty by default. Overwrite and implement all the necessary operations here
     //## and get the necessary information from the parameter operation.
     void ExecuteOperation(Operation *operation) override;
 
     /**
     * \brief Set the BaseGeometry of the data, which will be referenced (not copied!).
     * Assumes the data object has only 1 time step ( is a 3D object ) and creates a
     * new TimeGeometry which saves the given BaseGeometry. If an TimeGeometry has already
     * been set for the object, it will be replaced after calling this function.
     *
     * @warning This method will normally be called internally by the sub-class of BaseData
     * during initialization.
     * \sa SetClonedGeometry
     */
     virtual void SetGeometry(BaseGeometry *aGeometry3D);
 
     /**
     * \brief Set the TimeGeometry of the data, which will be referenced (not copied!).
     *
     * @warning This method will normally be called internally by the sub-class of BaseData
     * during initialization.
     * \sa SetClonedTimeGeometry
     */
     virtual void SetTimeGeometry(TimeGeometry *geometry);
 
     /**
     * \brief Set a clone of the provided Geometry as Geometry of the data.
     * Assumes the data object has only 1 time step ( is a 3D object ) and
     * creates a new TimeGeometry. If an TimeGeometry has already
     * been set for the object, it will be replaced after calling this function.
     *
     * \sa SetGeometry
     */
     virtual void SetClonedGeometry(const BaseGeometry *aGeometry3D);
 
     /**
   * \brief Set a clone of the provided TimeGeometry as TimeGeometry of the data.
   *
   * \sa SetGeometry
   */
     virtual void SetClonedTimeGeometry(const TimeGeometry *geometry);
 
     //##Documentation
     //## @brief Set a clone of the provided geometry as BaseGeometry of a given time step.
     //##
     //## \sa SetGeometry
     virtual void SetClonedGeometry(const BaseGeometry *aGeometry3D, unsigned int time);
 
     //##Documentation
     //## @brief Get the data's property list
     //## @sa GetProperty
     //## @sa m_PropertyList
     mitk::PropertyList::Pointer GetPropertyList() const;
 
     //##Documentation
     //## @brief Set the data's property list
     //## @sa SetProperty
     //## @sa m_PropertyList
     void SetPropertyList(PropertyList *propertyList);
 
     //##Documentation
     //## @brief Get the property (instance of BaseProperty) with key @a propertyKey from the PropertyList,
     //## and set it to this, respectively;
     //## @sa GetPropertyList
     //## @sa m_PropertyList
     //## @sa m_MapOfPropertyLists
     mitk::BaseProperty::Pointer GetProperty(const char *propertyKey) const;
 
     void SetProperty(const char *propertyKey, BaseProperty *property);
 
     //##Documentation
     //## @brief Convenience method for setting the origin of
     //## the BaseGeometry instances of all time steps
     //##
     //## \warning Geometries contained in the BaseGeometry will
     //## \em not be changed, e.g. in case the BaseGeometry is a
     //## SlicedGeometry3D the origin will \em not be propagated
     //## to the contained slices. The sub-class SlicedData
     //## does this for the case that the SlicedGeometry3D is
     //## evenly spaced.
     virtual void SetOrigin(const Point3D &origin);
 
     /** \brief Get the process object that generated this data object.
      *
      * If there is no process object, then the data object has
      * been disconnected from the pipeline, or the data object
      * was created manually. (Note: we cannot use the GetObjectMacro()
      * defined in itkMacro because the mutual dependency of
      * DataObject and ProcessObject causes compile problems. Also,
      * a forward reference smart pointer is returned, not a smart pointer,
      * because of the circular dependency between the process and data object.)
      *
      * GetSource() returns a SmartPointer and not a WeakPointer
      * because it is assumed the code calling GetSource() wants to hold a
      * long term reference to the source. */
     itk::SmartPointer<mitk::BaseDataSource> GetSource() const;
 
     //##Documentation
     //## @brief Get the number of time steps from the TimeGeometry
     //## As the base data has not a data vector given by itself, the number
     //## of time steps is defined over the time sliced geometry. In sub classes,
     //## a better implementation could be over the length of the data vector.
     unsigned int GetTimeSteps() const { return m_TimeGeometry->CountTimeSteps(); }
     //##Documentation
     //## @brief Get the modified time of the last change of the contents
     //## this data object or its geometry.
     virtual unsigned long GetMTime() const override;
 
     /**
      * \sa itk::ProcessObject::Graft
      */
     virtual void Graft(const DataObject *) override;
 
   protected:
     BaseData();
     BaseData(const BaseData &other);
     ~BaseData();
 
     //##Documentation
     //## \brief Initialize the TimeGeometry for a number of time steps.
     //## The TimeGeometry is initialized empty and evenly timed.
     //## In many cases it will be necessary to overwrite this in sub-classes.
     virtual void InitializeTimeGeometry(unsigned int timeSteps = 1);
 
     /**
     * \brief Initialize the TimeGeometry for a number of time steps.
     * The TimeGeometry is initialized empty and evenly timed.
     * In many cases it will be necessary to overwrite this in sub-classes.
     * \deprecatedSince{2013_09} Please use GetUpdatedTimeGeometry instead: For additional information see
     * http://www.mitk.org/Development/Refactoring%20of%20the%20Geometry%20Classes%20-%20Part%201
     */
     DEPRECATED(virtual void InitializeTimeSlicedGeometry(unsigned int timeSteps = 1))
     {
       InitializeTimeGeometry(timeSteps);
     }
 
     //##Documentation
     //## @brief reset to non-initialized state, release memory
     virtual void ClearData();
 
     //##Documentation
     //## @brief Pure virtual; Must be used in subclasses to get a data object to a
     //## valid state. Should at least create one empty object and call
     //## Superclass::InitializeTimeGeometry() to ensure an existing valid geometry
     virtual void InitializeEmpty() {}
     virtual void PrintSelf(std::ostream &os, itk::Indent indent) const override;
 
     bool m_LastRequestedRegionWasOutsideOfTheBufferedRegion;
 
     mutable unsigned int m_SourceOutputIndexDuplicate;
 
     bool m_Initialized;
 
   private:
     //##Documentation
     //## @brief PropertyList, f.e. to hold pic-tags, tracking-data,..
     //##
     PropertyList::Pointer m_PropertyList;
 
     TimeGeometry::Pointer m_TimeGeometry;
   };
 
 } // namespace mitk
 
 #endif /* BASEDATA_H_HEADER_INCLUDED_C1EBB6FA */
diff --git a/Modules/Core/include/mitkDataNode.h b/Modules/Core/include/mitkDataNode.h
index a6e0036d58..b30e0e2dc8 100644
--- a/Modules/Core/include/mitkDataNode.h
+++ b/Modules/Core/include/mitkDataNode.h
@@ -1,614 +1,611 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef DATATREENODE_H_HEADER_INCLUDED_C1E14338
 #define DATATREENODE_H_HEADER_INCLUDED_C1E14338
 
 #include "mitkBaseData.h"
 //#include "mitkMapper.h"
 #include "mitkDataInteractor.h"
-#include "mitkIIdentifiable.h"
+#include "mitkIdentifiable.h"
 #include "mitkIPropertyOwner.h"
 
 #ifdef MBI_NO_STD_NAMESPACE
 #define MBI_STD
 #include <fstream.h>
 #include <iostream.h>
 #else
 #define MBI_STD std
 #include <fstream>
 #include <iostream>
 #endif
 
 #include "mitkColorProperty.h"
 #include "mitkPropertyList.h"
 #include "mitkStringProperty.h"
 //#include "mitkMapper.h"
 
 #include "mitkGeometry3D.h"
 #include "mitkLevelWindow.h"
 #include <map>
 #include <set>
 
 class vtkLinearTransform;
 
 namespace mitk
 {
   class BaseRenderer;
   class Mapper;
 
   /**
    * \brief Class for nodes of the DataTree
    *
    * Contains the data (instance of BaseData), a list of mappers, which can
    * draw the data, a transform (vtkTransform) and a list of properties
    * (PropertyList).
    * \ingroup DataManagement
    *
    * \todo clean up all the GetProperty methods. There are too many different flavours... Can most probably be reduced
    * to
    * <tt>bool GetProperty<type>(type&)</tt>
    *
    * \warning Change in semantics of SetProperty() since Aug 25th 2006. Check your usage of this method if you do
    *          more with properties than just call <tt>SetProperty( "key", new SomeProperty("value") )</tt>.
    */
-  class MITKCORE_EXPORT DataNode : public itk::DataObject, public IIdentifiable, public IPropertyOwner
+  class MITKCORE_EXPORT DataNode : public itk::DataObject, public Identifiable, public IPropertyOwner
   {
   public:
     typedef mitk::Geometry3D::Pointer Geometry3DPointer;
     typedef std::vector<itk::SmartPointer<Mapper>> MapperVector;
     typedef std::map<std::string, mitk::PropertyList::Pointer> MapOfPropertyLists;
     typedef std::vector<MapOfPropertyLists::key_type> PropertyListKeyNames;
     typedef std::set<std::string> GroupTagList;
 
     /**
      * \brief Definition of an itk::Event that is invoked when
      * a DataInteractor is set on this DataNode.
      */
     itkEventMacro(InteractorChangedEvent, itk::AnyEvent)
     mitkClassMacroItkParent(DataNode, itk::DataObject)
     itkFactorylessNewMacro(Self)
     itkCloneMacro(Self)
 
-    // IIdentifiable
-    virtual UIDType GetUID() const override;
-
     // IPropertyProvider
-    virtual BaseProperty::ConstPointer GetConstProperty(const std::string &propertyName, const std::string &contextName = "", bool fallBackOnDefaultContext = true) const override;
-    virtual std::vector<std::string> GetPropertyNames(const std::string &contextName = "", bool includeDefaultContext = false) const override;
+    virtual BaseProperty::ConstPointer GetConstProperty(const std::string &propertyKey, const std::string &contextName = "", bool fallBackOnDefaultContext = true) const override;
+    virtual std::vector<std::string> GetPropertyKeys(const std::string &contextName = "", bool includeDefaultContext = false) const override;
     virtual std::vector<std::string> GetPropertyContextNames() const override;
 
     // IPropertyOwner
-    virtual BaseProperty * GetNonConstProperty(const std::string &propertyName, const std::string &contextName = "", bool fallBackOnDefaultContext = true) override;
-    virtual void SetProperty(const std::string &propertyName, BaseProperty *property, const std::string &contextName = "", bool fallBackOnDefaultContext = false) override;
+    virtual BaseProperty * GetNonConstProperty(const std::string &propertyKey, const std::string &contextName = "", bool fallBackOnDefaultContext = true) override;
+    virtual void SetProperty(const std::string &propertyKey, BaseProperty *property, const std::string &contextName = "", bool fallBackOnDefaultContext = false) override;
 
     mitk::Mapper *GetMapper(MapperSlotId id) const;
 
     /**
      * \brief Get the data object (instance of BaseData, e.g., an Image)
      * managed by this DataNode
      */
     BaseData *GetData() const;
 
     /**
      * \brief Get the transformation applied prior to displaying the data as
      * a vtkTransform
      * \deprecated use GetData()->GetGeometry()->GetVtkTransform() instead
      */
     vtkLinearTransform *GetVtkTransform(int t = 0) const;
 
     /**
      * \brief Set the data object (instance of BaseData, e.g., an Image)
      * managed by this DataNode
      *
      * Prior set properties are kept if previous data of the node already exists and has the same
      * type as the new data to be set. Otherwise, the default properties are used.
      * In case that previous data already exists, the property list of the data node is cleared
      * before setting new default properties.
      *
      * \warning the actor-mode of the vtkInteractor does not work any more, if the transform of the
      * data-tree-node is connected to the transform of the basedata via vtkTransform->SetInput.
      */
     virtual void SetData(mitk::BaseData *baseData);
 
     /**
      * \brief Set the Interactor.
      */
     virtual void SetDataInteractor(const DataInteractor::Pointer interactor);
     virtual DataInteractor::Pointer GetDataInteractor() const;
 
     mitk::DataNode &operator=(const DataNode &right);
 
     mitk::DataNode &operator=(BaseData *right);
     virtual void SetMapper(MapperSlotId id, mitk::Mapper *mapper);
     virtual void UpdateOutputInformation() override;
 
     virtual void SetRequestedRegionToLargestPossibleRegion() override;
 
     virtual bool RequestedRegionIsOutsideOfTheBufferedRegion() override;
 
     virtual bool VerifyRequestedRegion() override;
 
     virtual void SetRequestedRegion(const itk::DataObject *data) override;
 
     virtual void CopyInformation(const itk::DataObject *data) override;
 
     /**
      * \brief The "names" used for (renderer-specific) PropertyLists in GetPropertyList(string).
      *
      * All possible values for the "renderer" parameters of
      * the diverse GetProperty/List() methods.
      */
     PropertyListKeyNames GetPropertyListNames() const;
 
     /**
      * \brief Set the property (instance of BaseProperty) with key \a propertyKey in the PropertyList
      * of the \a renderer (if nullptr, use BaseRenderer-independent PropertyList). This is set-by-value.
      *
      * \warning Change in semantics since Aug 25th 2006. Check your usage of this method if you do
      *          more with properties than just call <tt>SetProperty( "key", new SomeProperty("value") )</tt>.
      *
      * \sa GetProperty
      * \sa m_PropertyList
      * \sa m_MapOfPropertyLists
      */
     void SetProperty(const char *propertyKey, BaseProperty *property, const mitk::BaseRenderer *renderer = nullptr);
 
     /**
      * \brief Replace the property (instance of BaseProperty) with key \a propertyKey in the PropertyList
      * of the \a renderer (if nullptr, use BaseRenderer-independent PropertyList). This is set-by-reference.
      *
      * If \a renderer is \a nullptr the property is set in the BaseRenderer-independent
      * PropertyList of this DataNode.
      * \sa GetProperty
      * \sa m_PropertyList
      * \sa m_MapOfPropertyLists
      */
     void ReplaceProperty(const char *propertyKey, BaseProperty *property, const mitk::BaseRenderer *renderer = nullptr);
 
     /**
      * \brief Add the property (instance of BaseProperty) if it does
      * not exist (or always if\a overwrite is\a true)
      * with key \a propertyKey in the PropertyList
      * of the \a renderer (if nullptr, use BaseRenderer-independent
      * PropertyList). This is set-by-value.
      *
      * For\a overwrite ==\a false the property is\em not changed
      * if it already exists. For\a overwrite ==\a true the method
      * is identical to SetProperty.
      *
      * \sa SetProperty
      * \sa GetProperty
      * \sa m_PropertyList
      * \sa m_MapOfPropertyLists
      */
     void AddProperty(const char *propertyKey,
                      BaseProperty *property,
                      const mitk::BaseRenderer *renderer = nullptr,
                      bool overwrite = false);
 
     /**
      * \brief Get the PropertyList of the \a renderer. If \a renderer is \a
      * nullptr, the BaseRenderer-independent PropertyList of this DataNode
      * is returned.
      * \sa GetProperty
      * \sa m_PropertyList
      * \sa m_MapOfPropertyLists
      */
     mitk::PropertyList *GetPropertyList(const mitk::BaseRenderer *renderer = nullptr) const;
     mitk::PropertyList *GetPropertyList(const std::string &rendererName) const;
 
     /**
      * \brief Add values from another PropertyList.
      *
      * Overwrites values in m_PropertyList only when possible (i.e. when types are compatible).
      * If you want to allow for object type changes (replacing a "visible":BoolProperty with "visible":IntProperty,
      * set the \param replace.
      *
      * \param replace true: if \param pList contains a property "visible" of type ColorProperty and our m_PropertyList
      * also has a "visible" property of a different type (e.g. BoolProperty), change the type, i.e. replace the objects
      * behind the pointer.
      *
      * \sa SetProperty
      * \sa ReplaceProperty
      * \sa m_PropertyList
      */
     void ConcatenatePropertyList(PropertyList *pList, bool replace = false);
 
     /**
      * \brief Get the property (instance of BaseProperty) with key \a propertyKey from the PropertyList
      * of the \a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList.
      *
      * If \a renderer is \a nullptr or the \a propertyKey cannot be found
      * in the PropertyList specific to \a renderer or is disabled there, the BaseRenderer-independent
      * PropertyList of this DataNode is queried.
      *
      * If \a fallBackOnDataProperties is true, the data property list is queried as a last resort.
      *
      * \sa GetPropertyList
      * \sa m_PropertyList
      * \sa m_MapOfPropertyLists
      */
     mitk::BaseProperty *GetProperty(const char *propertyKey, const mitk::BaseRenderer *renderer = nullptr, bool fallBackOnDataProperties = true) const;
 
     /**
      * \brief Get the property of type T with key \a propertyKey from the PropertyList
      * of the \a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList.
      *
      * If \a renderer is \a nullptr or the \a propertyKey cannot be found
      * in the PropertyList specific to \a renderer or is disabled there, the BaseRenderer-independent
      * PropertyList of this DataNode is queried.
      * \sa GetPropertyList
      * \sa m_PropertyList
      * \sa m_MapOfPropertyLists
      */
     template <typename T>
     bool GetProperty(itk::SmartPointer<T> &property,
                      const char *propertyKey,
                      const mitk::BaseRenderer *renderer = nullptr) const
     {
       property = dynamic_cast<T *>(GetProperty(propertyKey, renderer));
       return property.IsNotNull();
     }
 
     /**
      * \brief Get the property of type T with key \a propertyKey from the PropertyList
      * of the \a renderer, if available there, otherwise use the BaseRenderer-independent PropertyList.
      *
      * If \a renderer is \a nullptr or the \a propertyKey cannot be found
      * in the PropertyList specific to \a renderer or is disabled there, the BaseRenderer-independent
      * PropertyList of this DataNode is queried.
      * \sa GetPropertyList
      * \sa m_PropertyList
      * \sa m_MapOfPropertyLists
      */
     template <typename T>
     bool GetProperty(T *&property, const char *propertyKey, const mitk::BaseRenderer *renderer = nullptr) const
     {
       property = dynamic_cast<T *>(GetProperty(propertyKey, renderer));
       return property != nullptr;
     }
 
     /**
      * \brief Convenience access method for GenericProperty<T> properties
      * (T being the type of the second parameter)
      * \return \a true property was found
      */
     template <typename T>
     bool GetPropertyValue(const char *propertyKey, T &value, const mitk::BaseRenderer *renderer = nullptr) const
     {
       GenericProperty<T> *gp = dynamic_cast<GenericProperty<T> *>(GetProperty(propertyKey, renderer));
       if (gp != nullptr)
       {
         value = gp->GetValue();
         return true;
       }
       return false;
     }
 
     /// \brief Get a set of all group tags from this node's property list
     GroupTagList GetGroupTags() const;
 
     /**
      * \brief Convenience access method for bool properties (instances of
      * BoolProperty)
      * \return \a true property was found
      */
     bool GetBoolProperty(const char *propertyKey, bool &boolValue, const mitk::BaseRenderer *renderer = nullptr) const;
 
     /**
      * \brief Convenience access method for int properties (instances of
      * IntProperty)
      * \return \a true property was found
      */
     bool GetIntProperty(const char *propertyKey, int &intValue, const mitk::BaseRenderer *renderer = nullptr) const;
 
     /**
      * \brief Convenience access method for float properties (instances of
      * FloatProperty)
      * \return \a true property was found
      */
     bool GetFloatProperty(const char *propertyKey,
                           float &floatValue,
                           const mitk::BaseRenderer *renderer = nullptr) const;
 
     /**
      * \brief Convenience access method for double properties (instances of
      * DoubleProperty)
      *
      * If there is no DoubleProperty for the given\c propertyKey argument, the method
      * looks for a corresponding FloatProperty instance.
      *
      * \return \a true property was found
      */
     bool GetDoubleProperty(const char *propertyKey,
                            double &doubleValue,
                            const mitk::BaseRenderer *renderer = nullptr) const;
 
     /**
      * \brief Convenience access method for string properties (instances of
      * StringProperty)
      * \return \a true property was found
      */
     bool GetStringProperty(const char *propertyKey,
                            std::string &string,
                            const mitk::BaseRenderer *renderer = nullptr) const;
 
     /**
      * \brief Convenience access method for color properties (instances of
      * ColorProperty)
      * \return \a true property was found
      */
     bool GetColor(float rgb[3], const mitk::BaseRenderer *renderer = nullptr, const char *propertyKey = "color") const;
 
     /**
      * \brief Convenience access method for level-window properties (instances of
      * LevelWindowProperty)
      * \return \a true property was found
      */
     bool GetLevelWindow(mitk::LevelWindow &levelWindow,
                         const mitk::BaseRenderer *renderer = nullptr,
                         const char *propertyKey = "levelwindow") const;
 
     /**
      * \brief set the node as selected
      */
     void SetSelected(bool selected, const mitk::BaseRenderer *renderer = nullptr);
 
     /**
      * \brief set the node as selected
      * \return \a true node is selected
      */
     bool IsSelected(const mitk::BaseRenderer *renderer = nullptr);
 
     /**
      * \brief Convenience access method for accessing the name of an object (instance of
      * StringProperty with property-key "name")
      * \return \a true property was found
      */
     bool GetName(std::string &nodeName,
                  const mitk::BaseRenderer *renderer = nullptr,
                  const char *propertyKey = "name") const
     {
       return GetStringProperty(propertyKey, nodeName, renderer);
     }
 
     /**
      * \brief Extra convenience access method for accessing the name of an object (instance of
      * StringProperty with property-key "name").
      *
      * This method does not take the renderer specific
      * propertylists into account, because the name of an object should never be renderer specific.
      * \returns a std::string with the name of the object (content of "name" Property).
      * If there is no "name" Property, an empty string will be returned.
      */
     virtual std::string GetName() const
     {
       mitk::StringProperty *sp = dynamic_cast<mitk::StringProperty *>(this->GetProperty("name"));
       if (sp == nullptr)
         return "";
       return sp->GetValue();
     }
 
     /**
      * \brief Extra convenience access method to set the name of an object.
      *
      * The name will be stored in the non-renderer-specific PropertyList in a StringProperty named "name".
      */
     virtual void SetName(const char *name)
     {
       if (name == nullptr)
         return;
       this->SetProperty("name", StringProperty::New(name));
     }
     /**
      * \brief Extra convenience access method to set the name of an object.
      *
      * The name will be stored in the non-renderer-specific PropertyList in a StringProperty named "name".
      */
     virtual void SetName(const std::string name) { this->SetName(name.c_str()); }
     /**
      * \brief Convenience access method for visibility properties (instances
      * of BoolProperty with property-key "visible")
      * \return \a true property was found
      * \sa IsVisible
      */
     bool GetVisibility(bool &visible, const mitk::BaseRenderer *renderer, const char *propertyKey = "visible") const
     {
       return GetBoolProperty(propertyKey, visible, renderer);
     }
 
     /**
      * \brief Convenience access method for opacity properties (instances of
      * FloatProperty)
      * \return \a true property was found
      */
     bool GetOpacity(float &opacity, const mitk::BaseRenderer *renderer, const char *propertyKey = "opacity") const;
 
     /**
      * \brief Convenience access method for boolean properties (instances
      * of BoolProperty). Return value is the value of the property. If the property is
      * not found, the value of \a defaultIsOn is returned.
      *
      * Thus, the return value has a different meaning than in the
      * GetBoolProperty method!
      * \sa GetBoolProperty
      */
     bool IsOn(const char *propertyKey, const mitk::BaseRenderer *renderer, bool defaultIsOn = true) const
     {
       if (propertyKey == nullptr)
         return defaultIsOn;
       GetBoolProperty(propertyKey, defaultIsOn, renderer);
       return defaultIsOn;
     }
 
     /**
      * \brief Convenience access method for visibility properties (instances
      * of BoolProperty). Return value is the visibility. Default is
      * visible==true, i.e., true is returned even if the property (\a
      * propertyKey) is not found.
      *
      * Thus, the return value has a different meaning than in the
      * GetVisibility method!
      * \sa GetVisibility
      * \sa IsOn
      */
     bool IsVisible(const mitk::BaseRenderer *renderer,
                    const char *propertyKey = "visible",
                    bool defaultIsOn = true) const
     {
       return IsOn(propertyKey, renderer, defaultIsOn);
     }
 
     /**
      * \brief Convenience method for setting color properties (instances of
      * ColorProperty)
      */
     void SetColor(const mitk::Color &color,
                   const mitk::BaseRenderer *renderer = nullptr,
                   const char *propertyKey = "color");
 
     /**
      * \brief Convenience method for setting color properties (instances of
      * ColorProperty)
      */
     void SetColor(float red,
                   float green,
                   float blue,
                   const mitk::BaseRenderer *renderer = nullptr,
                   const char *propertyKey = "color");
 
     /**
      * \brief Convenience method for setting color properties (instances of
      * ColorProperty)
      */
     void SetColor(const float rgb[3], const mitk::BaseRenderer *renderer = nullptr, const char *propertyKey = "color");
 
     /**
      * \brief Convenience method for setting visibility properties (instances
      * of BoolProperty)
      * \param visible If set to true, the data will be rendered. If false, the render will skip this data.
      * \param renderer Specify a renderer if the visibility shall be specific to a renderer
      * \param propertykey Can be used to specify a user defined name of the visibility propery.
      */
     void SetVisibility(bool visible, const mitk::BaseRenderer *renderer = nullptr, const char *propertyKey = "visible");
 
     /**
      * \brief Convenience method for setting opacity properties (instances of
      * FloatProperty)
      */
     void SetOpacity(float opacity, const mitk::BaseRenderer *renderer = nullptr, const char *propertyKey = "opacity");
 
     /**
      * \brief Convenience method for setting level-window properties
      * (instances of LevelWindowProperty)
      */
     void SetLevelWindow(mitk::LevelWindow levelWindow,
                         const mitk::BaseRenderer *renderer = nullptr,
                         const char *propertyKey = "levelwindow");
 
     /**
      * \brief Convenience method for setting int properties (instances of
      * IntProperty)
      */
     void SetIntProperty(const char *propertyKey, int intValue, const mitk::BaseRenderer *renderer = nullptr);
 
     /**
      * \brief Convenience method for setting boolean properties (instances of
      * BoolProperty)
      */
     void SetBoolProperty(const char *propertyKey, bool boolValue, const mitk::BaseRenderer *renderer = nullptr);
 
     /**
      * \brief Convenience method for setting float properties (instances of
      * FloatProperty)
      */
     void SetFloatProperty(const char *propertyKey, float floatValue, const mitk::BaseRenderer *renderer = nullptr);
 
     /**
      * \brief Convenience method for setting double properties (instances of
      * DoubleProperty)
      */
     void SetDoubleProperty(const char *propertyKey, double doubleValue, const mitk::BaseRenderer *renderer = nullptr);
 
     /**
      * \brief Convenience method for setting string properties (instances of
      * StringProperty)
      */
     void SetStringProperty(const char *propertyKey, const char *string, const mitk::BaseRenderer *renderer = nullptr);
 
     /**
      * \brief Get the timestamp of the last change of the contents of this node or
      * the referenced BaseData.
      */
     virtual unsigned long GetMTime() const override;
 
     /**
      * \brief Get the timestamp of the last change of the reference to the
      * BaseData.
      */
     unsigned long GetDataReferenceChangedTime() const { return m_DataReferenceChangedTime.GetMTime(); }
 
   protected:
     DataNode();
 
     virtual ~DataNode();
 
     /// Invoked when the property list was modified. Calls Modified() of the DataNode
     virtual void PropertyListModified(const itk::Object *caller, const itk::EventObject &event);
 
     /// \brief Mapper-slots
     mutable MapperVector m_Mappers;
 
     /**
      * \brief The data object (instance of BaseData, e.g., an Image) managed
      * by this DataNode
      */
     BaseData::Pointer m_Data;
 
     /**
      * \brief BaseRenderer-independent PropertyList
      *
      * Properties herein can be overwritten specifically for each BaseRenderer
      * by the BaseRenderer-specific properties defined in m_MapOfPropertyLists.
      */
     PropertyList::Pointer m_PropertyList;
 
     /// \brief Map associating each BaseRenderer with its own PropertyList
     mutable MapOfPropertyLists m_MapOfPropertyLists;
 
     DataInteractor::Pointer m_DataInteractor;
 
     /// \brief Timestamp of the last change of m_Data
     itk::TimeStamp m_DataReferenceChangedTime;
 
     unsigned long m_PropertyListModifiedObserverTag;
   };
 
 #if (_MSC_VER > 1200) || !defined(_MSC_VER)
   MITKCORE_EXPORT MBI_STD::istream &operator>>(MBI_STD::istream &i, DataNode::Pointer &dtn);
 
   MITKCORE_EXPORT MBI_STD::ostream &operator<<(MBI_STD::ostream &o, DataNode::Pointer &dtn);
 #endif
 } // namespace mitk
 
 #if ((defined(_MSC_VER)) && (_MSC_VER <= 1200))
 MITKCORE_EXPORT MBI_STD::istream &operator>>(MBI_STD::istream &i, mitk::DataNode::Pointer &dtn);
 
 MITKCORE_EXPORT MBI_STD::ostream &operator<<(MBI_STD::ostream &o, mitk::DataNode::Pointer &dtn);
 #endif
 
 #endif /* DATATREENODE_H_HEADER_INCLUDED_C1E14338 */
diff --git a/Modules/Core/include/mitkIPropertyOwner.h b/Modules/Core/include/mitkIPropertyOwner.h
index 938f145767..a92e66b644 100644
--- a/Modules/Core/include/mitkIPropertyOwner.h
+++ b/Modules/Core/include/mitkIPropertyOwner.h
@@ -1,59 +1,59 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef mitkIPropertyOwner_h
 #define mitkIPropertyOwner_h
 
 #include <mitkIPropertyProvider.h>
 #include <MitkCoreExports.h>
 
 namespace mitk
 {
   class MITKCORE_EXPORT IPropertyOwner : public IPropertyProvider
   {
   public:
     virtual ~IPropertyOwner();
 
     /**
-    * \brief Get property by its name.
+    * \brief Get property by its key.
     *
-    * \param[in] propertyName Name of property.
+    * \param[in] propertyKey Key of property.
     * \param[in] contextName Optional, default is empty string (default
     *            context). Search in specified context.
     * \param[in] fallBackOnDefaultContext Optional, default is true. Also
     *            search in default context if property was not found in given
     *            context.
     *
     * \return Found property, nullptr otherwise.
     */
-    virtual BaseProperty * GetNonConstProperty(const std::string &propertyName, const std::string &contextName = "", bool fallBackOnDefaultContext = true) = 0;
+    virtual BaseProperty * GetNonConstProperty(const std::string &propertyKey, const std::string &contextName = "", bool fallBackOnDefaultContext = true) = 0;
 
     /**
     * \brief Add new or change existent property.
     *
-    * \param[in] propertyName Name of property.
+    * \param[in] propertyKey Key of property.
     * \param[in] property The actual property.
     * \param[in] contextName Optional, default is empty string (default
                  context). Context in which the property is set.
     * \param[in] fallBackOnDefaultContext Optional, default is false. Set
     *            property in default context if given context does not
     *            exist.
     */
-    virtual void SetProperty(const std::string &propertyName, BaseProperty *property, const std::string &contextName = "", bool fallBackOnDefaultContext = false) = 0;
+    virtual void SetProperty(const std::string &propertyKey, BaseProperty *property, const std::string &contextName = "", bool fallBackOnDefaultContext = false) = 0;
   };
 }
 
 #endif
diff --git a/Modules/Core/include/mitkIPropertyProvider.h b/Modules/Core/include/mitkIPropertyProvider.h
index 2187e4972f..440516d80b 100644
--- a/Modules/Core/include/mitkIPropertyProvider.h
+++ b/Modules/Core/include/mitkIPropertyProvider.h
@@ -1,65 +1,65 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef mitkIPropertyProvider_h
 #define mitkIPropertyProvider_h
 
 #include <mitkBaseProperty.h>
 #include <MitkCoreExports.h>
 
 namespace mitk
 {
   class MITKCORE_EXPORT IPropertyProvider
   {
   public:
     virtual ~IPropertyProvider();
 
     /**
-    * \brief Get property by its name.
+    * \brief Get property by its key.
     *
-    * \param[in] propertyName Name of property.
+    * \param[in] propertyKey Key of property.
     * \param[in] contextName Optional, default is empty string (default
     *            context). Search in specified context.
     * \param[in] fallBackOnDefaultContext Optional, default is true. Also
     *            search in default context if property was not found in given
     *            context.
     *
     * \return Found property, nullptr otherwise.
     */
-    virtual BaseProperty::ConstPointer GetConstProperty(const std::string &propertyName, const std::string &contextName = "", bool fallBackOnDefaultContext = true) const = 0;
+    virtual BaseProperty::ConstPointer GetConstProperty(const std::string &propertyKey, const std::string &contextName = "", bool fallBackOnDefaultContext = true) const = 0;
 
     /**
-    * \brief Query names of existing properties.
+    * \brief Query keys of existing properties.
     *
     * \param[in] contextName Optional, default is empty string (default
     *            context). Search in specified context.
     * \param[in] includeDefaultContext Optional, default is false. Include
     *            default context.
     *
-    * \return List of property names.
+    * \return List of property keys.
     */
-    virtual std::vector<std::string> GetPropertyNames(const std::string &contextName = "", bool includeDefaultContext = false) const = 0;
+    virtual std::vector<std::string> GetPropertyKeys(const std::string &contextName = "", bool includeDefaultContext = false) const = 0;
 
     /**
     * \brief Query names of existing contexts.
     *
     * \return List of context names.
     */
     virtual std::vector<std::string> GetPropertyContextNames() const = 0;
   };
 }
 
 #endif
diff --git a/Modules/Core/include/mitkIdentifiable.h b/Modules/Core/include/mitkIdentifiable.h
new file mode 100644
index 0000000000..be092cc44e
--- /dev/null
+++ b/Modules/Core/include/mitkIdentifiable.h
@@ -0,0 +1,64 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#ifndef mitkIdentifiable_h
+#define mitkIdentifiable_h
+
+#include <string>
+#include <MitkCoreExports.h>
+
+namespace mitk
+{
+  /**
+   * \brief Base class of identifiable objects.
+   *
+   * If you want to change the unique ID after creation time, you can use
+   * the mitk::UIDManipulator class. The reationale behind this pattern is
+   * to ensure that you think twice before doing this. It is intended to be
+   * used by data readers if necessary at all.
+   */
+  class MITKCORE_EXPORT Identifiable
+  {
+  public:
+    using UIDType = std::string;
+
+    Identifiable();
+    explicit Identifiable(const UIDType &uid);
+    Identifiable(const Identifiable &) = delete;
+    Identifiable(Identifiable &&) noexcept;
+    virtual ~Identifiable();
+
+    Identifiable & operator =(const Identifiable &) = delete;
+    Identifiable & operator =(Identifiable &&other) noexcept;
+
+    /**
+     * \brief Get unique ID of an object.
+     *
+     * \return Empty string if an object has no unique ID.
+     */
+    UIDType GetUID() const;
+
+  private:
+    friend class UIDManipulator;
+
+    void SetUID(const UIDType &uid);
+
+    struct Impl;
+    Impl *m_Impl;
+  };
+}
+
+#endif
diff --git a/Modules/Core/include/mitkNodePredicateDataUID.h b/Modules/Core/include/mitkNodePredicateDataUID.h
index 0ae1633fb5..dcd9c0ebec 100644
--- a/Modules/Core/include/mitkNodePredicateDataUID.h
+++ b/Modules/Core/include/mitkNodePredicateDataUID.h
@@ -1,48 +1,48 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef mitkNodePredicateDataUID_h
 #define mitkNodePredicateDataUID_h
 
-#include <mitkIIdentifiable.h>
+#include <mitkIdentifiable.h>
 #include <mitkNodePredicateBase.h>
 #include <MitkCoreExports.h>
 
 namespace mitk
 {
   /**
    * \brief Predicate that compares the data UID of the given DataNode to a specific UID.
    *
    * \ingroup DataStorage
    */
   class MITKCORE_EXPORT NodePredicateDataUID : public NodePredicateBase
   {
   public:
     mitkClassMacro(NodePredicateDataUID, NodePredicateBase)
-    mitkNewMacro1Param(NodePredicateDataUID, const IIdentifiable::UIDType &)
+    mitkNewMacro1Param(NodePredicateDataUID, const Identifiable::UIDType &)
 
     virtual ~NodePredicateDataUID();
 
     virtual bool CheckNode(const mitk::DataNode *node) const override;
 
   protected:
-    explicit NodePredicateDataUID(const IIdentifiable::UIDType &uid);
+    explicit NodePredicateDataUID(const Identifiable::UIDType &uid);
 
-    IIdentifiable::UIDType m_UID;
+    Identifiable::UIDType m_UID;
   };
 }
 
 #endif
diff --git a/Modules/Core/include/mitkNodePredicateUID.h b/Modules/Core/include/mitkNodePredicateUID.h
index 3b6503b906..38c9ff223a 100644
--- a/Modules/Core/include/mitkNodePredicateUID.h
+++ b/Modules/Core/include/mitkNodePredicateUID.h
@@ -1,48 +1,48 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #ifndef mitkNodePredicateUID_h
 #define mitkNodePredicateUID_h
 
-#include <mitkIIdentifiable.h>
+#include <mitkIdentifiable.h>
 #include <mitkNodePredicateBase.h>
 #include <MitkCoreExports.h>
 
 namespace mitk
 {
   /**
   * \brief Predicate that compares the UID of the given DataNode to a specific UID.
   *
   * \ingroup DataStorage
   */
   class MITKCORE_EXPORT NodePredicateUID : public NodePredicateBase
   {
   public:
     mitkClassMacro(NodePredicateUID, NodePredicateBase)
-    mitkNewMacro1Param(NodePredicateUID, const IIdentifiable::UIDType &)
+    mitkNewMacro1Param(NodePredicateUID, const Identifiable::UIDType &)
 
     virtual ~NodePredicateUID();
 
     virtual bool CheckNode(const mitk::DataNode *node) const override;
 
   protected:
-    explicit NodePredicateUID(const IIdentifiable::UIDType &uid);
+    explicit NodePredicateUID(const Identifiable::UIDType &uid);
 
-    IIdentifiable::UIDType m_UID;
+    Identifiable::UIDType m_UID;
   };
 }
 
 #endif
diff --git a/Modules/Core/include/mitkIIdentifiable.h b/Modules/Core/include/mitkUIDManipulator.h
similarity index 54%
rename from Modules/Core/include/mitkIIdentifiable.h
rename to Modules/Core/include/mitkUIDManipulator.h
index a81d8ded51..3172a6c230 100644
--- a/Modules/Core/include/mitkIIdentifiable.h
+++ b/Modules/Core/include/mitkUIDManipulator.h
@@ -1,43 +1,48 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
-#ifndef mitkIIdentifiable_h
-#define mitkIIdentifiable_h
+#ifndef mitkUIDManipulator_h
+#define mitkUIDManipulator_h
 
-#include <string>
+#include <mitkIdentifiable.h>
 #include <MitkCoreExports.h>
 
 namespace mitk
 {
+  class Identifiable;
+
   /**
-   * \brief Interface of identifiable objects.
+   * \brief Change the unique ID of an mitk::Identifiable.
+   *
+   * Think twice before doing this. Intended for data readers.
    */
-  class MITKCORE_EXPORT IIdentifiable
+  class MITKCORE_EXPORT UIDManipulator final
   {
   public:
-    using UIDType = std::string;
-    virtual ~IIdentifiable();
+    explicit UIDManipulator(Identifiable *identifiable);
+    ~UIDManipulator();
 
     /**
-     * \brief Get unique ID of an object.
-     *
-     * \return Empty string if an object has no unique ID.
+     * \brief Set unique ID of an identifiable object.
      */
-    virtual UIDType GetUID() const = 0;
+    void SetUID(const Identifiable::UIDType &uid);
+
+  private:
+    Identifiable *m_Identifiable;
   };
 }
 
 #endif
diff --git a/Modules/Core/src/DataManagement/mitkBaseData.cpp b/Modules/Core/src/DataManagement/mitkBaseData.cpp
index 137cfc0a34..ed26ebf474 100644
--- a/Modules/Core/src/DataManagement/mitkBaseData.cpp
+++ b/Modules/Core/src/DataManagement/mitkBaseData.cpp
@@ -1,358 +1,346 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkBaseData.h"
 
 #include <itkObjectFactoryBase.h>
 #include <mitkException.h>
 #include <mitkGeometry3D.h>
 #include <mitkProportionalTimeGeometry.h>
 #include <mitkStringProperty.h>
-#include <mitkUIDGenerator.h>
 
 mitk::BaseData::BaseData()
   : m_SourceOutputIndexDuplicate(0),
     m_Initialized(true),
     m_PropertyList(PropertyList::New()),
     m_TimeGeometry(ProportionalTimeGeometry::New())
 {
-  UIDGenerator generator;
-  this->SetProperty("uid", StringProperty::New(generator.GetUID()));
 }
 
 mitk::BaseData::BaseData(const BaseData &other)
   : itk::DataObject(),
     mitk::OperationActor(),
     m_SourceOutputIndexDuplicate(other.m_SourceOutputIndexDuplicate),
     m_Initialized(other.m_Initialized),
     m_PropertyList(other.m_PropertyList->Clone()),
     m_TimeGeometry(other.m_TimeGeometry->Clone())
 {
 }
 
 mitk::BaseData::~BaseData()
 {
 }
 
 void mitk::BaseData::InitializeTimeGeometry(unsigned int timeSteps)
 {
   mitk::Geometry3D::Pointer geo3D = mitk::Geometry3D::New();
   mitk::BaseGeometry::Pointer baseGeo = dynamic_cast<BaseGeometry *>(geo3D.GetPointer());
   baseGeo->Initialize();
 
   // The geometry is propagated automatically to the other items,
   // if EvenlyTimed is true...
   // Old timeGeometry->InitializeEvenlyTimed( g3d.GetPointer(), timeSteps );
 
   TimeGeometry::Pointer timeGeometry = this->GetTimeGeometry();
   timeGeometry->Initialize();
   timeGeometry->Expand(timeSteps);
   for (TimeStepType step = 0; step < timeSteps; ++step)
   {
     timeGeometry->SetTimeStepGeometry(baseGeo.GetPointer(), step);
   }
 }
 
 void mitk::BaseData::UpdateOutputInformation()
 {
   if (this->GetSource())
   {
     this->GetSource()->UpdateOutputInformation();
   }
   if (m_TimeGeometry.IsNotNull())
   {
     m_TimeGeometry->UpdateBoundingBox();
   }
 }
 
 const mitk::TimeGeometry *mitk::BaseData::GetUpdatedTimeGeometry()
 {
   SetRequestedRegionToLargestPossibleRegion();
 
   UpdateOutputInformation();
 
   return GetTimeGeometry();
 }
 
 void mitk::BaseData::Expand(unsigned int timeSteps)
 {
   if (m_TimeGeometry.IsNotNull())
   {
     m_TimeGeometry->Expand(timeSteps);
   }
   else
   {
     this->InitializeTimeGeometry(timeSteps);
   }
 }
 
 const mitk::BaseGeometry *mitk::BaseData::GetUpdatedGeometry(int t)
 {
   SetRequestedRegionToLargestPossibleRegion();
 
   UpdateOutputInformation();
 
   return GetGeometry(t);
 }
 
 void mitk::BaseData::SetGeometry(BaseGeometry *geometry)
 {
   ProportionalTimeGeometry::Pointer timeGeometry = ProportionalTimeGeometry::New();
   if (geometry != nullptr)
   {
     timeGeometry->Initialize(geometry, 1);
   }
   SetTimeGeometry(timeGeometry);
   return;
 }
 
 void mitk::BaseData::SetTimeGeometry(TimeGeometry *geometry)
 {
   m_TimeGeometry = geometry;
   this->Modified();
 }
 
 void mitk::BaseData::SetClonedGeometry(const BaseGeometry *aGeometry3D)
 {
   SetGeometry(static_cast<mitk::BaseGeometry *>(aGeometry3D->Clone().GetPointer()));
 }
 
 void mitk::BaseData::SetClonedTimeGeometry(const TimeGeometry *geometry)
 {
   TimeGeometry::Pointer clonedGeometry = geometry->Clone();
   SetTimeGeometry(clonedGeometry.GetPointer());
 }
 
 void mitk::BaseData::SetClonedGeometry(const BaseGeometry *aGeometry3D, unsigned int time)
 {
   if (m_TimeGeometry)
   {
     m_TimeGeometry->SetTimeStepGeometry(static_cast<mitk::BaseGeometry *>(aGeometry3D->Clone().GetPointer()), time);
   }
 }
 
 bool mitk::BaseData::IsEmptyTimeStep(unsigned int) const
 {
   return IsInitialized() == false;
 }
 
 bool mitk::BaseData::IsEmpty() const
 {
   if (IsInitialized() == false)
     return true;
   const TimeGeometry *timeGeometry = const_cast<BaseData *>(this)->GetUpdatedTimeGeometry();
   if (timeGeometry == nullptr)
     return true;
   unsigned int timeSteps = timeGeometry->CountTimeSteps();
   for (unsigned int t = 0; t < timeSteps; ++t)
   {
     if (IsEmptyTimeStep(t) == false)
       return false;
   }
   return true;
 }
 
 itk::SmartPointer<mitk::BaseDataSource> mitk::BaseData::GetSource() const
 {
   return static_cast<mitk::BaseDataSource *>(Superclass::GetSource().GetPointer());
 }
 
 mitk::PropertyList::Pointer mitk::BaseData::GetPropertyList() const
 {
   return m_PropertyList;
 }
 
 mitk::BaseProperty::Pointer mitk::BaseData::GetProperty(const char *propertyKey) const
 {
   return m_PropertyList->GetProperty(propertyKey);
 }
 
 void mitk::BaseData::SetProperty(const char *propertyKey, BaseProperty *propertyValue)
 {
   m_PropertyList->SetProperty(propertyKey, propertyValue);
 }
 
 void mitk::BaseData::SetPropertyList(PropertyList *pList)
 {
   m_PropertyList = pList;
 }
 
 void mitk::BaseData::SetOrigin(const mitk::Point3D &origin)
 {
   TimeGeometry *timeGeom = GetTimeGeometry();
 
   assert(timeGeom != nullptr);
 
   TimeStepType steps = timeGeom->CountTimeSteps();
   for (TimeStepType timestep = 0; timestep < steps; ++timestep)
   {
     auto geometry = GetGeometry(timestep);
     if (geometry != nullptr)
     {
       geometry->SetOrigin(origin);
     }
   }
 }
 
 unsigned long mitk::BaseData::GetMTime() const
 {
   unsigned long time = Superclass::GetMTime();
   if (m_TimeGeometry.IsNotNull())
   {
     if ((time < m_TimeGeometry->GetMTime()))
     {
       Modified();
       return Superclass::GetMTime();
     }
   }
   return time;
 }
 
 void mitk::BaseData::Graft(const itk::DataObject *)
 {
   itkExceptionMacro(<< "Graft not implemented for mitk::BaseData subclass " << this->GetNameOfClass())
 }
 
 void mitk::BaseData::CopyInformation(const itk::DataObject *data)
 {
   const auto *bd = dynamic_cast<const Self *>(data);
   if (bd != nullptr)
   {
     m_PropertyList = bd->GetPropertyList()->Clone();
     if (bd->GetTimeGeometry() != nullptr)
     {
       m_TimeGeometry = bd->GetTimeGeometry()->Clone();
     }
   }
   else
   {
     // pointer could not be cast back down; this can be the case if your filters input
     // and output objects differ in type; then you have to write your own GenerateOutputInformation method
     itkExceptionMacro(<< "mitk::BaseData::CopyInformation() cannot cast " << typeid(data).name() << " to "
                       << typeid(Self *).name());
   }
 }
 
 bool mitk::BaseData::IsInitialized() const
 {
   return m_Initialized;
 }
 
 void mitk::BaseData::Clear()
 {
   this->ClearData();
   this->InitializeEmpty();
 }
 
 void mitk::BaseData::ClearData()
 {
   if (m_Initialized)
   {
     ReleaseData();
     m_Initialized = false;
   }
 }
 
 void mitk::BaseData::ExecuteOperation(mitk::Operation * /*operation*/)
 {
   // empty by default. override if needed!
 }
 
 void mitk::BaseData::PrintSelf(std::ostream &os, itk::Indent indent) const
 {
   os << std::endl;
   os << indent << " TimeGeometry: ";
   if (GetTimeGeometry() == nullptr)
     os << "nullptr" << std::endl;
   else
     GetTimeGeometry()->Print(os, indent);
   // print out all properties
   PropertyList::Pointer propertyList = this->GetPropertyList();
   if (propertyList.IsNotNull() && !propertyList->IsEmpty())
   {
     // general headline
     os << "Properties of BaseData:" << std::endl;
 
     const PropertyList::PropertyMap *map = propertyList->GetMap();
     for (auto iter = map->begin(); iter != map->end(); ++iter)
     {
       os << "  " << (*iter).first << "   " << (*iter).second->GetValueAsString() << std::endl;
     }
   }
 }
 
-mitk::IIdentifiable::UIDType mitk::BaseData::GetUID() const
+mitk::BaseProperty::ConstPointer mitk::BaseData::GetConstProperty(const std::string &propertyKey, const std::string &contextName, bool fallBackOnDefaultContext) const
 {
-  auto uidProperty = dynamic_cast<StringProperty *>(this->GetProperty("uid").GetPointer());
-
-  return nullptr != uidProperty
-    ? uidProperty->GetValue()
-    : "";
-}
-
-mitk::BaseProperty::ConstPointer mitk::BaseData::GetConstProperty(const std::string &propertyName, const std::string &contextName, bool fallBackOnDefaultContext) const
-{
-  if (propertyName.empty())
+  if (propertyKey.empty())
     return nullptr;
 
   if (contextName.empty() || fallBackOnDefaultContext)
-    return m_PropertyList->GetProperty(propertyName);
+    return m_PropertyList->GetProperty(propertyKey);
 
   return nullptr;
 }
 
-mitk::BaseProperty * mitk::BaseData::GetNonConstProperty(const std::string &propertyName, const std::string &contextName, bool fallBackOnDefaultContext)
+mitk::BaseProperty * mitk::BaseData::GetNonConstProperty(const std::string &propertyKey, const std::string &contextName, bool fallBackOnDefaultContext)
 {
-  if (propertyName.empty())
+  if (propertyKey.empty())
     return nullptr;
 
   if (contextName.empty() || fallBackOnDefaultContext)
-    return m_PropertyList->GetProperty(propertyName);
+    return m_PropertyList->GetProperty(propertyKey);
 
   return nullptr;
 }
 
-void mitk::BaseData::SetProperty(const std::string &propertyName, BaseProperty *property, const std::string &contextName, bool fallBackOnDefaultContext)
+void mitk::BaseData::SetProperty(const std::string &propertyKey, BaseProperty *property, const std::string &contextName, bool fallBackOnDefaultContext)
 {
-  if (propertyName.empty())
-    mitkThrow() << "Property name is empty.";
+  if (propertyKey.empty())
+    mitkThrow() << "Property key is empty.";
 
   if (contextName.empty() || fallBackOnDefaultContext)
   {
-    m_PropertyList->SetProperty(propertyName, property);
+    m_PropertyList->SetProperty(propertyKey, property);
     return;
   }
 
   mitkThrow() << "Unknown property context.";
 }
 
-std::vector<std::string> mitk::BaseData::GetPropertyNames(const std::string &contextName, bool includeDefaultContext) const
+std::vector<std::string> mitk::BaseData::GetPropertyKeys(const std::string &contextName, bool includeDefaultContext) const
 {
-  std::vector<std::string> propertyNames;
+  std::vector<std::string> propertyKeys;
 
   if (contextName.empty() || includeDefaultContext)
   {
     for (auto property : *m_PropertyList->GetMap())
-      propertyNames.push_back(property.first);
+      propertyKeys.push_back(property.first);
   }
 
-  return propertyNames;
+  return propertyKeys;
 }
 
 std::vector<std::string> mitk::BaseData::GetPropertyContextNames() const
 {
   return std::vector<std::string>();
 }
diff --git a/Modules/Core/src/DataManagement/mitkDataNode.cpp b/Modules/Core/src/DataManagement/mitkDataNode.cpp
index 691efeb8be..282d143448 100644
--- a/Modules/Core/src/DataManagement/mitkDataNode.cpp
+++ b/Modules/Core/src/DataManagement/mitkDataNode.cpp
@@ -1,724 +1,711 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include "mitkDataNode.h"
 #include "mitkCoreObjectFactory.h"
 #include <vtkTransform.h>
 
 #include "mitkGroupTagProperty.h"
 #include "mitkProperties.h"
 #include "mitkSmartPointerProperty.h"
 #include "mitkStringProperty.h"
 //#include "mitkMaterialProperty.h"
 #include "mitkColorProperty.h"
 #include "mitkCoreObjectFactory.h"
 #include "mitkGenericProperty.h"
 #include "mitkGeometry3D.h"
 #include "mitkImageSource.h"
 #include "mitkLevelWindowProperty.h"
 #include "mitkRenderingManager.h"
-#include <mitkUIDGenerator.h>
 
 mitk::Mapper *mitk::DataNode::GetMapper(MapperSlotId id) const
 {
   if ((id >= m_Mappers.size()) || (m_Mappers[id].IsNull()))
   {
     if (id >= m_Mappers.capacity())
     {
       //      int i, size=id-m_Mappers.capacity()+10;
       m_Mappers.resize(id + 10);
     }
     m_Mappers[id] = CoreObjectFactory::GetInstance()->CreateMapper(const_cast<DataNode *>(this), id);
   }
   return m_Mappers[id];
 }
 
 mitk::BaseData *mitk::DataNode::GetData() const
 {
   return m_Data;
 }
 
 void mitk::DataNode::SetData(mitk::BaseData *baseData)
 {
   if (m_Data != baseData)
   {
     m_Mappers.clear();
     m_Mappers.resize(10);
 
     if (m_Data.IsNotNull() && baseData != nullptr)
     {
       // Do previous and new data have same type? Keep existing properties.
       if (0 == strcmp(m_Data->GetNameOfClass(), baseData->GetNameOfClass()))
       {
         m_Data = baseData;
       }
       else
       {
         m_Data = baseData;
         this->GetPropertyList()->Clear();
         mitk::CoreObjectFactory::GetInstance()->SetDefaultProperties(this);
       }
     }
     else
     {
       m_Data = baseData;
       mitk::CoreObjectFactory::GetInstance()->SetDefaultProperties(this);
     }
 
     m_DataReferenceChangedTime.Modified();
     Modified();
   }
 }
 
 mitk::DataNode::DataNode()
   : m_PropertyList(PropertyList::New()),
     m_PropertyListModifiedObserverTag(0)
 {
   m_Mappers.resize(10);
 
-  UIDGenerator generator;
-  this->SetProperty("uid", StringProperty::New(generator.GetUID()));
-
   // subscribe for modified event
   itk::MemberCommand<mitk::DataNode>::Pointer _PropertyListModifiedCommand = itk::MemberCommand<mitk::DataNode>::New();
   _PropertyListModifiedCommand->SetCallbackFunction(this, &mitk::DataNode::PropertyListModified);
   m_PropertyListModifiedObserverTag = m_PropertyList->AddObserver(itk::ModifiedEvent(), _PropertyListModifiedCommand);
 }
 
 mitk::DataNode::~DataNode()
 {
   if (m_PropertyList.IsNotNull())
     m_PropertyList->RemoveObserver(m_PropertyListModifiedObserverTag);
 
   m_Mappers.clear();
   m_Data = nullptr;
 }
 
 mitk::DataNode &mitk::DataNode::operator=(const DataNode &right)
 {
   mitk::DataNode *node = mitk::DataNode::New();
   node->SetData(right.GetData());
   return *node;
 }
 
 mitk::DataNode &mitk::DataNode::operator=(mitk::BaseData *right)
 {
   mitk::DataNode *node = mitk::DataNode::New();
   node->SetData(right);
   return *node;
 }
 
 #if (_MSC_VER > 1200) || !defined(_MSC_VER)
 MBI_STD::istream &mitk::operator>>(MBI_STD::istream &i, mitk::DataNode::Pointer &dtn)
 #endif
 #if ((defined(_MSC_VER)) && (_MSC_VER <= 1200))
   MBI_STD::istream &
   operator>>(MBI_STD::istream &i, mitk::DataNode::Pointer &dtn)
 #endif
 {
   dtn = mitk::DataNode::New();
   // i >> av.get();
   return i;
 }
 
 #if (_MSC_VER > 1200) || !defined(_MSC_VER)
 MBI_STD::ostream &mitk::operator<<(MBI_STD::ostream &o, mitk::DataNode::Pointer &dtn)
 #endif
 #if ((defined(_MSC_VER)) && (_MSC_VER <= 1200))
   MBI_STD::ostream &
   operator<<(MBI_STD::ostream &o, mitk::DataNode::Pointer &dtn)
 #endif
 {
   if (dtn->GetData() != nullptr)
     o << dtn->GetData()->GetNameOfClass();
   else
     o << "empty data";
   return o;
 }
 
 void mitk::DataNode::SetMapper(MapperSlotId id, mitk::Mapper *mapper)
 {
   m_Mappers[id] = mapper;
 
   if (mapper != nullptr)
     mapper->SetDataNode(this);
 }
 
 void mitk::DataNode::UpdateOutputInformation()
 {
   if (this->GetSource())
   {
     this->GetSource()->UpdateOutputInformation();
   }
 }
 
 void mitk::DataNode::SetRequestedRegionToLargestPossibleRegion()
 {
 }
 
 bool mitk::DataNode::RequestedRegionIsOutsideOfTheBufferedRegion()
 {
   return false;
 }
 
 bool mitk::DataNode::VerifyRequestedRegion()
 {
   return true;
 }
 
 void mitk::DataNode::SetRequestedRegion(const itk::DataObject * /*data*/)
 {
 }
 
 mitk::DataNode::PropertyListKeyNames mitk::DataNode::GetPropertyListNames() const
 {
   PropertyListKeyNames result;
 
   for (auto entries : m_MapOfPropertyLists)
     result.push_back(entries.first);
 
   return result;
 }
 
 void mitk::DataNode::CopyInformation(const itk::DataObject * /*data*/)
 {
 }
 mitk::PropertyList *mitk::DataNode::GetPropertyList(const mitk::BaseRenderer *renderer) const
 {
   if (renderer == nullptr)
     return m_PropertyList;
 
   return this->GetPropertyList(renderer->GetName());
 }
 
 mitk::PropertyList *mitk::DataNode::GetPropertyList(const std::string &rendererName) const
 {
   if (rendererName.empty())
     return m_PropertyList;
 
   mitk::PropertyList::Pointer &propertyList = m_MapOfPropertyLists[rendererName];
 
   if (propertyList.IsNull())
     propertyList = mitk::PropertyList::New();
 
   assert(m_MapOfPropertyLists[rendererName].IsNotNull());
 
   return propertyList;
 }
 
 void mitk::DataNode::ConcatenatePropertyList(PropertyList *pList, bool replace)
 {
   m_PropertyList->ConcatenatePropertyList(pList, replace);
 }
 
 mitk::BaseProperty *mitk::DataNode::GetProperty(const char *propertyKey, const mitk::BaseRenderer *renderer, bool fallBackOnDataProperties) const
 {
   if (nullptr == propertyKey)
     return nullptr;
 
   if (nullptr != renderer)
   {
     auto it = m_MapOfPropertyLists.find(renderer->GetName());
 
     if (m_MapOfPropertyLists.end() != it)
     {
       auto property = it->second->GetProperty(propertyKey);
 
       if (nullptr != property)
         return property;
     }
   }
 
   auto property = m_PropertyList->GetProperty(propertyKey);
 
   if (nullptr == property && fallBackOnDataProperties && m_Data.IsNotNull())
     property = m_Data->GetProperty(propertyKey);
 
   return property;
 }
 
 mitk::DataNode::GroupTagList mitk::DataNode::GetGroupTags() const
 {
   GroupTagList groups;
   const PropertyList::PropertyMap *propertyMap = m_PropertyList->GetMap();
 
   for (auto groupIter =
          propertyMap->begin(); // m_PropertyList is created in the constructor, so we don't check it here
        groupIter != propertyMap->end();
        ++groupIter)
   {
     const BaseProperty *bp = groupIter->second;
     if (dynamic_cast<const GroupTagProperty *>(bp))
     {
       groups.insert(groupIter->first);
     }
   }
 
   return groups;
 }
 
 bool mitk::DataNode::GetBoolProperty(const char *propertyKey, bool &boolValue, const mitk::BaseRenderer *renderer) const
 {
   mitk::BoolProperty::Pointer boolprop = dynamic_cast<mitk::BoolProperty *>(GetProperty(propertyKey, renderer));
   if (boolprop.IsNull())
     return false;
 
   boolValue = boolprop->GetValue();
   return true;
 }
 
 bool mitk::DataNode::GetIntProperty(const char *propertyKey, int &intValue, const mitk::BaseRenderer *renderer) const
 {
   mitk::IntProperty::Pointer intprop = dynamic_cast<mitk::IntProperty *>(GetProperty(propertyKey, renderer));
   if (intprop.IsNull())
     return false;
 
   intValue = intprop->GetValue();
   return true;
 }
 
 bool mitk::DataNode::GetFloatProperty(const char *propertyKey,
                                       float &floatValue,
                                       const mitk::BaseRenderer *renderer) const
 {
   mitk::FloatProperty::Pointer floatprop = dynamic_cast<mitk::FloatProperty *>(GetProperty(propertyKey, renderer));
   if (floatprop.IsNull())
     return false;
 
   floatValue = floatprop->GetValue();
   return true;
 }
 
 bool mitk::DataNode::GetDoubleProperty(const char *propertyKey,
                                        double &doubleValue,
                                        const mitk::BaseRenderer *renderer) const
 {
   mitk::DoubleProperty::Pointer doubleprop = dynamic_cast<mitk::DoubleProperty *>(GetProperty(propertyKey, renderer));
   if (doubleprop.IsNull())
   {
     // try float instead
     float floatValue = 0;
     if (this->GetFloatProperty(propertyKey, floatValue, renderer))
     {
       doubleValue = floatValue;
       return true;
     }
     return false;
   }
 
   doubleValue = doubleprop->GetValue();
   return true;
 }
 
 bool mitk::DataNode::GetStringProperty(const char *propertyKey,
                                        std::string &string,
                                        const mitk::BaseRenderer *renderer) const
 {
   mitk::StringProperty::Pointer stringProp = dynamic_cast<mitk::StringProperty *>(GetProperty(propertyKey, renderer));
   if (stringProp.IsNull())
   {
     return false;
   }
   else
   {
     // memcpy((void*)string, stringProp->GetValue(), strlen(stringProp->GetValue()) + 1 ); // looks dangerous
     string = stringProp->GetValue();
     return true;
   }
 }
 
 bool mitk::DataNode::GetColor(float rgb[3], const mitk::BaseRenderer *renderer, const char *propertyKey) const
 {
   mitk::ColorProperty::Pointer colorprop = dynamic_cast<mitk::ColorProperty *>(GetProperty(propertyKey, renderer));
   if (colorprop.IsNull())
     return false;
 
   memcpy(rgb, colorprop->GetColor().GetDataPointer(), 3 * sizeof(float));
   return true;
 }
 
 bool mitk::DataNode::GetOpacity(float &opacity, const mitk::BaseRenderer *renderer, const char *propertyKey) const
 {
   mitk::FloatProperty::Pointer opacityprop = dynamic_cast<mitk::FloatProperty *>(GetProperty(propertyKey, renderer));
   if (opacityprop.IsNull())
     return false;
 
   opacity = opacityprop->GetValue();
   return true;
 }
 
 bool mitk::DataNode::GetLevelWindow(mitk::LevelWindow &levelWindow,
                                     const mitk::BaseRenderer *renderer,
                                     const char *propertyKey) const
 {
   mitk::LevelWindowProperty::Pointer levWinProp =
     dynamic_cast<mitk::LevelWindowProperty *>(GetProperty(propertyKey, renderer));
   if (levWinProp.IsNull())
     return false;
 
   levelWindow = levWinProp->GetLevelWindow();
   return true;
 }
 
 void mitk::DataNode::SetColor(const mitk::Color &color, const mitk::BaseRenderer *renderer, const char *propertyKey)
 {
   mitk::ColorProperty::Pointer prop;
   prop = mitk::ColorProperty::New(color);
   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
 }
 
 void mitk::DataNode::SetColor(
   float red, float green, float blue, const mitk::BaseRenderer *renderer, const char *propertyKey)
 {
   float color[3];
   color[0] = red;
   color[1] = green;
   color[2] = blue;
   SetColor(color, renderer, propertyKey);
 }
 
 void mitk::DataNode::SetColor(const float rgb[3], const mitk::BaseRenderer *renderer, const char *propertyKey)
 {
   mitk::ColorProperty::Pointer prop;
   prop = mitk::ColorProperty::New(rgb);
   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
 }
 
 void mitk::DataNode::SetVisibility(bool visible, const mitk::BaseRenderer *renderer, const char *propertyKey)
 {
   mitk::BoolProperty::Pointer prop;
   prop = mitk::BoolProperty::New(visible);
   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
 }
 
 void mitk::DataNode::SetOpacity(float opacity, const mitk::BaseRenderer *renderer, const char *propertyKey)
 {
   mitk::FloatProperty::Pointer prop;
   prop = mitk::FloatProperty::New(opacity);
   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
 }
 
 void mitk::DataNode::SetLevelWindow(mitk::LevelWindow levelWindow,
                                     const mitk::BaseRenderer *renderer,
                                     const char *propertyKey)
 {
   mitk::LevelWindowProperty::Pointer prop;
   prop = mitk::LevelWindowProperty::New(levelWindow);
   GetPropertyList(renderer)->SetProperty(propertyKey, prop);
 }
 
 void mitk::DataNode::SetIntProperty(const char *propertyKey, int intValue, const mitk::BaseRenderer *renderer)
 {
   GetPropertyList(renderer)->SetProperty(propertyKey, mitk::IntProperty::New(intValue));
 }
 void mitk::DataNode::SetBoolProperty(const char *propertyKey,
                                      bool boolValue,
                                      const mitk::BaseRenderer *renderer /*=nullptr*/)
 {
   GetPropertyList(renderer)->SetProperty(propertyKey, mitk::BoolProperty::New(boolValue));
 }
 
 void mitk::DataNode::SetFloatProperty(const char *propertyKey,
                                       float floatValue,
                                       const mitk::BaseRenderer *renderer /*=nullptr*/)
 {
   if (dynamic_cast<DoubleProperty *>(this->GetProperty(propertyKey, renderer)) != nullptr)
   {
     MITK_WARN << "Setting float property " << propertyKey
               << " although a double property with the same name already exists";
   }
   GetPropertyList(renderer)->SetProperty(propertyKey, mitk::FloatProperty::New(floatValue));
 }
 
 void mitk::DataNode::SetDoubleProperty(const char *propertyKey, double doubleValue, const mitk::BaseRenderer *renderer)
 {
   if (dynamic_cast<FloatProperty *>(this->GetProperty(propertyKey, renderer)) != nullptr)
   {
     MITK_WARN << "Setting double property " << propertyKey
               << " although a float property with the same name already exists";
   }
   GetPropertyList(renderer)->SetProperty(propertyKey, mitk::DoubleProperty::New(doubleValue));
 }
 
 void mitk::DataNode::SetStringProperty(const char *propertyKey,
                                        const char *stringValue,
                                        const mitk::BaseRenderer *renderer /*=nullptr*/)
 {
   GetPropertyList(renderer)->SetProperty(propertyKey, mitk::StringProperty::New(stringValue));
 }
 
 void mitk::DataNode::SetProperty(const char *propertyKey,
                                  BaseProperty *propertyValue,
                                  const mitk::BaseRenderer *renderer)
 {
   GetPropertyList(renderer)->SetProperty(propertyKey, propertyValue);
 }
 
 void mitk::DataNode::ReplaceProperty(const char *propertyKey,
                                      BaseProperty *propertyValue,
                                      const mitk::BaseRenderer *renderer)
 {
   GetPropertyList(renderer)->ReplaceProperty(propertyKey, propertyValue);
 }
 
 void mitk::DataNode::AddProperty(const char *propertyKey,
                                  BaseProperty *propertyValue,
                                  const mitk::BaseRenderer *renderer,
                                  bool overwrite)
 {
   if ((overwrite) || (GetProperty(propertyKey, renderer) == nullptr))
   {
     SetProperty(propertyKey, propertyValue, renderer);
   }
 }
 
 vtkLinearTransform *mitk::DataNode::GetVtkTransform(int t) const
 {
   assert(m_Data.IsNotNull());
 
   mitk::BaseGeometry *geometry = m_Data->GetGeometry(t);
 
   if (geometry == nullptr)
     return nullptr;
 
   return geometry->GetVtkTransform();
 }
 
 unsigned long mitk::DataNode::GetMTime() const
 {
   unsigned long time = Superclass::GetMTime();
   if (m_Data.IsNotNull())
   {
     if ((time < m_Data->GetMTime()) || ((m_Data->GetSource().IsNotNull()) && (time < m_Data->GetSource()->GetMTime())))
     {
       Modified();
       return Superclass::GetMTime();
     }
   }
   return time;
 }
 
 void mitk::DataNode::SetSelected(bool selected, const mitk::BaseRenderer *renderer)
 {
   mitk::BoolProperty::Pointer selectedProperty = dynamic_cast<mitk::BoolProperty *>(GetProperty("selected"));
 
   if (selectedProperty.IsNull())
   {
     selectedProperty = mitk::BoolProperty::New();
     selectedProperty->SetValue(false);
     SetProperty("selected", selectedProperty, renderer);
   }
 
   if (selectedProperty->GetValue() != selected)
   {
     selectedProperty->SetValue(selected);
     itk::ModifiedEvent event;
     InvokeEvent(event);
   }
 }
 
 /*
 class SelectedEvent : public itk::ModifiedEvent
 {
 public:
   typedef SelectedEvent Self;
   typedef itk::ModifiedEvent Superclass;
 
   SelectedEvent(DataNode* dataNode)
     { m_DataNode = dataNode; };
   DataNode* GetDataNode()
     { return m_DataNode; };
   virtual const char * GetEventName() const
     { return "SelectedEvent"; }
   virtual bool CheckEvent(const ::itk::EventObject* e) const
     { return dynamic_cast<const Self*>(e); }
   virtual ::itk::EventObject* MakeObject() const
     { return new Self(m_DataNode); }
 private:
   DataNode* m_DataNode;
   SelectedEvent(const Self& event)
     { m_DataNode = event.m_DataNode; };
   void operator=(const Self& event)
   { m_DataNode = event.m_DataNode; }
 };
 */
 
 bool mitk::DataNode::IsSelected(const mitk::BaseRenderer *renderer)
 {
   bool selected;
 
   if (!GetBoolProperty("selected", selected, renderer))
     return false;
 
   return selected;
 }
 
 void mitk::DataNode::SetDataInteractor(const DataInteractor::Pointer interactor)
 {
   if (m_DataInteractor == interactor)
     return;
 
   m_DataInteractor = interactor;
   this->Modified();
 
   mitk::DataNode::InteractorChangedEvent changedEvent;
   this->InvokeEvent(changedEvent);
 }
 
 mitk::DataInteractor::Pointer mitk::DataNode::GetDataInteractor() const
 {
   return m_DataInteractor;
 }
 
 void mitk::DataNode::PropertyListModified(const itk::Object * /*caller*/, const itk::EventObject &)
 {
   Modified();
 }
 
-mitk::IIdentifiable::UIDType mitk::DataNode::GetUID() const
-{
-  auto uidProperty = dynamic_cast<StringProperty *>(this->GetProperty("uid", nullptr, false));
-
-  return nullptr != uidProperty
-    ? uidProperty->GetValue()
-    : "";
-}
-
-mitk::BaseProperty::ConstPointer mitk::DataNode::GetConstProperty(const std::string &propertyName, const std::string &contextName, bool fallBackOnDefaultContext) const
+mitk::BaseProperty::ConstPointer mitk::DataNode::GetConstProperty(const std::string &propertyKey, const std::string &contextName, bool fallBackOnDefaultContext) const
 {
-  if (propertyName.empty())
+  if (propertyKey.empty())
     return nullptr;
 
   if (!contextName.empty())
   {
     auto propertyListIter = m_MapOfPropertyLists.find(contextName);
 
     if (m_MapOfPropertyLists.end() != propertyListIter)
     {
-      BaseProperty::ConstPointer property = propertyListIter->second->GetProperty(propertyName);
+      BaseProperty::ConstPointer property = propertyListIter->second->GetProperty(propertyKey);
 
       if (property.IsNotNull())
         return property;
     }
   }
 
   if (contextName.empty() || fallBackOnDefaultContext)
   {
-    BaseProperty::ConstPointer property = m_PropertyList->GetProperty(propertyName);
+    BaseProperty::ConstPointer property = m_PropertyList->GetProperty(propertyKey);
 
     if (property.IsNull() && m_Data.IsNull())
-      property = m_Data->GetProperty(propertyName.c_str());
+      property = m_Data->GetProperty(propertyKey.c_str());
 
     return property;
   }
 
   return nullptr;
 }
 
-mitk::BaseProperty * mitk::DataNode::GetNonConstProperty(const std::string &propertyName, const std::string &contextName, bool fallBackOnDefaultContext)
+mitk::BaseProperty * mitk::DataNode::GetNonConstProperty(const std::string &propertyKey, const std::string &contextName, bool fallBackOnDefaultContext)
 {
-  if (propertyName.empty())
+  if (propertyKey.empty())
     return nullptr;
 
   if (!contextName.empty())
   {
     auto propertyListIter = m_MapOfPropertyLists.find(contextName);
 
     if (m_MapOfPropertyLists.end() != propertyListIter)
     {
-      auto property = propertyListIter->second->GetProperty(propertyName);
+      auto property = propertyListIter->second->GetProperty(propertyKey);
 
       if (nullptr != property)
         return property;
     }
   }
 
   if (contextName.empty() || fallBackOnDefaultContext)
   {
-    auto property = m_PropertyList->GetProperty(propertyName);
+    auto property = m_PropertyList->GetProperty(propertyKey);
 
     if (nullptr == property && m_Data.IsNull())
-      property = m_Data->GetProperty(propertyName.c_str());
+      property = m_Data->GetProperty(propertyKey.c_str());
 
     return property;
   }
 
   return nullptr;
 }
 
-void mitk::DataNode::SetProperty(const std::string &propertyName, BaseProperty *property, const std::string &contextName, bool fallBackOnDefaultContext)
+void mitk::DataNode::SetProperty(const std::string &propertyKey, BaseProperty *property, const std::string &contextName, bool fallBackOnDefaultContext)
 {
-  if (propertyName.empty())
-    mitkThrow() << "Property name is empty.";
+  if (propertyKey.empty())
+    mitkThrow() << "Property key is empty.";
 
   if (!contextName.empty())
   {
     auto propertyListIter = m_MapOfPropertyLists.find(contextName);
 
     if (m_MapOfPropertyLists.end() != propertyListIter)
     {
-      propertyListIter->second->SetProperty(propertyName, property);
+      propertyListIter->second->SetProperty(propertyKey, property);
       return;
     }
   }
 
   if (contextName.empty() || fallBackOnDefaultContext)
   {
-    m_PropertyList->SetProperty(propertyName, property);
+    m_PropertyList->SetProperty(propertyKey, property);
     return;
   }
 
   mitkThrow() << "Unknown property context.";
 }
 
-std::vector<std::string> mitk::DataNode::GetPropertyNames(const std::string &contextName, bool includeDefaultContext) const
+std::vector<std::string> mitk::DataNode::GetPropertyKeys(const std::string &contextName, bool includeDefaultContext) const
 {
-  std::vector<std::string> propertyNames;
+  std::vector<std::string> propertyKeys;
 
   if (contextName.empty())
   {
     for (auto property : *m_PropertyList->GetMap())
-      propertyNames.push_back(property.first);
+      propertyKeys.push_back(property.first);
 
-    return propertyNames;
+    return propertyKeys;
   }
 
   auto propertyListIter = m_MapOfPropertyLists.find(contextName);
 
   if (m_MapOfPropertyLists.end() != propertyListIter)
   {
     for (auto property : *propertyListIter->second->GetMap())
-      propertyNames.push_back(property.first);
+      propertyKeys.push_back(property.first);
   }
 
   if (includeDefaultContext)
   {
     for (auto property : *m_PropertyList->GetMap())
     {
-      auto propertyNameIter = std::find(propertyNames.begin(), propertyNames.end(), property.first);
+      auto propertyKeyIter = std::find(propertyKeys.begin(), propertyKeys.end(), property.first);
 
-      if (propertyNames.end() == propertyNameIter)
-        propertyNames.push_back(property.first);
+      if (propertyKeys.end() == propertyKeyIter)
+        propertyKeys.push_back(property.first);
     }
   }
 
-  return propertyNames;
+  return propertyKeys;
 }
 
 std::vector<std::string> mitk::DataNode::GetPropertyContextNames() const
 {
   return this->GetPropertyListNames();
 }
diff --git a/Modules/Core/src/DataManagement/mitkIdentifiable.cpp b/Modules/Core/src/DataManagement/mitkIdentifiable.cpp
new file mode 100644
index 0000000000..dc22cd1069
--- /dev/null
+++ b/Modules/Core/src/DataManagement/mitkIdentifiable.cpp
@@ -0,0 +1,66 @@
+/*===================================================================
+
+The Medical Imaging Interaction Toolkit (MITK)
+
+Copyright (c) German Cancer Research Center,
+Division of Medical and Biological Informatics.
+All rights reserved.
+
+This software is distributed WITHOUT ANY WARRANTY; without
+even the implied warranty of MERCHANTABILITY or FITNESS FOR
+A PARTICULAR PURPOSE.
+
+See LICENSE.txt or http://www.mitk.org for details.
+
+===================================================================*/
+
+#include <mitkIdentifiable.h>
+#include <mitkUIDGenerator.h>
+
+struct mitk::Identifiable::Impl
+{
+  UIDType uid;
+};
+
+mitk::Identifiable::Identifiable()
+  : m_Impl(new Impl)
+{
+  UIDGenerator generator;
+  m_Impl->uid = generator.GetUID();
+}
+
+mitk::Identifiable::Identifiable(const UIDType &uid)
+  : m_Impl(new Impl)
+{
+  m_Impl->uid = uid;
+}
+
+mitk::Identifiable::Identifiable(Identifiable &&other) noexcept
+  : m_Impl(other.m_Impl)
+{
+  other.m_Impl = nullptr;
+}
+
+mitk::Identifiable::~Identifiable()
+{
+  delete m_Impl;
+}
+
+mitk::Identifiable & mitk::Identifiable::operator =(Identifiable &&other) noexcept
+{
+  delete m_Impl;
+  m_Impl = other.m_Impl;
+  other.m_Impl = nullptr;
+
+  return *this;
+}
+
+mitk::Identifiable::UIDType mitk::Identifiable::GetUID() const
+{
+  return m_Impl->uid;
+}
+
+ void mitk::Identifiable::SetUID(const UIDType &uid)
+{
+  m_Impl->uid = uid;
+}
diff --git a/Modules/Core/src/DataManagement/mitkNodePredicateDataUID.cpp b/Modules/Core/src/DataManagement/mitkNodePredicateDataUID.cpp
index 462613c524..f15a632236 100644
--- a/Modules/Core/src/DataManagement/mitkNodePredicateDataUID.cpp
+++ b/Modules/Core/src/DataManagement/mitkNodePredicateDataUID.cpp
@@ -1,43 +1,43 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkNodePredicateDataUID.h>
 #include <mitkBaseData.h>
 #include <mitkDataNode.h>
 
-mitk::NodePredicateDataUID::NodePredicateDataUID(const IIdentifiable::UIDType &uid)
+mitk::NodePredicateDataUID::NodePredicateDataUID(const Identifiable::UIDType &uid)
   : m_UID(uid)
 {
 }
 
 mitk::NodePredicateDataUID::~NodePredicateDataUID()
 {
 }
 
 bool mitk::NodePredicateDataUID::CheckNode(const mitk::DataNode *node) const
 {
   if (nullptr != node)
   {
     auto data = node->GetData();
 
     if (nullptr != data)
     {
       return data->GetUID() == m_UID;
     }
   }
 
   return false;
 }
diff --git a/Modules/Core/src/DataManagement/mitkNodePredicateUID.cpp b/Modules/Core/src/DataManagement/mitkNodePredicateUID.cpp
index e5602ccf6d..a57ee8aa83 100644
--- a/Modules/Core/src/DataManagement/mitkNodePredicateUID.cpp
+++ b/Modules/Core/src/DataManagement/mitkNodePredicateUID.cpp
@@ -1,34 +1,34 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
 #include <mitkNodePredicateUID.h>
 #include <mitkDataNode.h>
 
-mitk::NodePredicateUID::NodePredicateUID(const IIdentifiable::UIDType &uid)
+mitk::NodePredicateUID::NodePredicateUID(const Identifiable::UIDType &uid)
   : m_UID(uid)
 {
 }
 
 mitk::NodePredicateUID::~NodePredicateUID()
 {
 }
 
 bool mitk::NodePredicateUID::CheckNode(const mitk::DataNode *node) const
 {
   return nullptr != node
     ? node->GetUID() == m_UID
     : false;
 }
diff --git a/Modules/Core/src/DataManagement/mitkIIdentifiable.cpp b/Modules/Core/src/DataManagement/mitkUIDManipulator.cpp
similarity index 54%
rename from Modules/Core/src/DataManagement/mitkIIdentifiable.cpp
rename to Modules/Core/src/DataManagement/mitkUIDManipulator.cpp
index 3ec216f717..8be1c2bb4b 100644
--- a/Modules/Core/src/DataManagement/mitkIIdentifiable.cpp
+++ b/Modules/Core/src/DataManagement/mitkUIDManipulator.cpp
@@ -1,21 +1,35 @@
 /*===================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center,
 Division of Medical and Biological Informatics.
 All rights reserved.
 
 This software is distributed WITHOUT ANY WARRANTY; without
 even the implied warranty of MERCHANTABILITY or FITNESS FOR
 A PARTICULAR PURPOSE.
 
 See LICENSE.txt or http://www.mitk.org for details.
 
 ===================================================================*/
 
-#include <mitkIIdentifiable.h>
+#include <mitkUIDManipulator.h>
+#include <mitkExceptionMacro.h>
+#include <mitkIdentifiable.h>
 
-mitk::IIdentifiable::~IIdentifiable()
+mitk::UIDManipulator::UIDManipulator(Identifiable *identifiable)
+  : m_Identifiable(identifiable)
 {
+  if (nullptr == m_Identifiable)
+    mitkThrow() << "Invalid identifiable object.";
+}
+
+mitk::UIDManipulator::~UIDManipulator()
+{
+}
+
+void mitk::UIDManipulator::SetUID(const Identifiable::UIDType &uid)
+{
+  m_Identifiable->SetUID(uid);
 }