diff --git a/Modules/Core/include/mitkPropertyRelationRuleBase.h b/Modules/Core/include/mitkPropertyRelationRuleBase.h
index d21919efb8..0be42d4709 100644
--- a/Modules/Core/include/mitkPropertyRelationRuleBase.h
+++ b/Modules/Core/include/mitkPropertyRelationRuleBase.h
@@ -1,374 +1,392 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #ifndef mitkPropertyRelationRuleBase_h
 #define mitkPropertyRelationRuleBase_h
 
 #include "mitkIPropertyOwner.h"
 #include "mitkIdentifiable.h"
 
 #include "mitkException.h"
 #include "mitkNodePredicateBase.h"
 #include "mitkPropertyKeyPath.h"
 
 #include <MitkCoreExports.h>
 
 #include <string>
 
 namespace mitk
 {
   /**Base class to standardize/abstract/encapsulate rules and business logic to detect and define
   (property/data based) relations in MITK.
   Following important definitions must be regarded when using/implementing/specifing rule classes:
   - Releations represented by rules are directed relations that point from a source IPropertyOwner (Source)
   to a destination IPropertyOwner (Destination).
   - Rule can be abstract (indicated by IsAbstract()) or concrete. Abstract rules cannot be used to connect relations.
   Abstract rules can only be used to detect/indicate or disconnect relations. Therefore, in contrast to concrete rules,
   abstract rules can be used to indicate several relations that are established be "derived" rules. See e.g. GenericIDRelationRule:
   in its abstract state it cannot connect but be used to detect any type of generic ID relation.
   - A concrete rule ID (rule ID of a concrete rule) always "implements" a concrete relation type. E.g. In DICOM the
   way to express the source image relation to an input image and to a mask would be nearly the same
   and only differs by the encoded purpose. One may implement an interim or joined class that manages the mutual
   stuff, but the registered instances must be one concrete rule for "DICOM source input image" and one concrete rule for
   "DICOM source mask" and both rules must have distinct rule IDs.
   - Source may have several relations of a rule to different Destinations.
   Destination may have several relations of a rule from different Sources. But a specific source destination
   pair may have only one relation of a specific rule id (concrete rule). A specific source destination
   pair may however have multiple relations for an abstract rule.
   - The deletion of a Destination in the storage does not remove the relation implicitly. It becomes a "zombie" relation
   but it should still be documented, even if the destination is unknown. One has to explicitly
   disconnect a zombie relation to get rid of it.
   - Each relation has its own UID (relationUID) that can be used to address it.
 
   The basic concept of the rule design is that we have two layers of relation identification: Layer 1 is the ID-layer
   which uses the IIdentifiable interface and UIDs if available to encode "hard" relations. Layer 2 is the Data-layer
   which uses the properties of Source and Destination to deduce if there is a relation of the rule type.
   The ID-layer is completely implemented by this base class. The base class falls back to the Data-layer
   (implemented by the concrete rule class) if the ID-layer is not sufficient or it is explicitly stated to (only)
   look at the data layer.
   Reasons for the introduction of the ID-layer are: 1st, data-defined relations may be weak (several Destinations are
   possible; e.g. DICOM source images may point to several loaded mitk images). But if explicitly a relation was
   connected it should be deduceable. 2nd, checks on a UID are faster then unnecessary data deduction.
 
   Rules use relation instance identifing (RII) properties in order to manage their relations that are stored in the
   Source. The RII-properties follow the following naming schema:
   "MITK.Relations.<InstanceID>.[relationUID|destinationUID|ruleID|<data-layer-specific>]"
   - <InstanceID>: The unique index of the relation for the Source. Used to assign/group the properties to
   their relation. In the default implementation of this class the instance id is an positive integer (i>0).
   - relationUID: The UID of the relation. Set by the ID-layer (so by this class)
   - destinationUID: The UID of the Destination. Set by the ID-layer (so by this class) if Destination implements
   IIdentifiable.
   - ruleID: The identifier of the concrete rule that sets the property. Is specified by the derived class and set
   automaticaly be this base class.
   - <data-layer-specific>: Information needed by the Data-layer (so derived classes) to find the relationUID
   */
   class MITKCORE_EXPORT PropertyRelationRuleBase : public itk::Object
   {
   public:
     mitkClassMacroItkParent(PropertyRelationRuleBase, itk::Object);
     itkCloneMacro(Self);
     itkCreateAnotherMacro(Self);
 
     using RuleIDType = std::string;
     using RelationUIDType = Identifiable::UIDType;
     using RelationUIDVectorType = std::vector<RelationUIDType>;
 
     /** Enum class for different types of relations. */
     enum class RelationType
     {
       None = 0,           /**< Two IPropertyOwner have no relation under the rule.*/
       Data = 1,  /**< Two IPropertyOwner have a relation, but it is "only" deduced from the Data-layer (so a bit
                    "weaker" as ID). Reasons for the missing ID connection could be that Destintination has not
                    IIdentifiable implemented.*/
       ID = 2,    /**< Two IPropertyOwner have a relation and are explictly connected via the ID of IIdentifiable of the Destination.*/
       Complete = 3    /**< Two IPropertyOwner have a relation and are fully explictly connected (via data layer and ID layer).*/
     };
     using RelationVectorType = std::vector<RelationType>;
 
     /** Returns the generic root path for relation rules ("MITK.Relations").*/
     static PropertyKeyPath GetRootKeyPath();
 
+    using InstanceIDType = std::string;
+    /** Returns the property key path for a RII property.
+     * @param propName If not empty a PropertyPath element will added (with the passed value) after the <InstenceID> element.
+     * @param instanceID If not empty, the PropertyKeyPath is only for a specific instance. If empty,
+     * it is wildcarded and will match RIIs property of any instance.*/
+    static PropertyKeyPath GetRIIPropertyKeyPath(const std::string propName, const InstanceIDType& instanceID);
+    /** Returns the property key path for RII RelationUID properties.
+     * @param instanceID If not empty, the PropertyKeyPath is only for a specific instance. If empty,
+     * it is wildcarded and will match RII RelationUIDs property of any instance.*/
+    static PropertyKeyPath GetRIIRelationUIDPropertyKeyPath(const InstanceIDType& instanceID = "");
+    /** Returns the property key path for RII RuleID properties.
+     * @param instanceID If not empty, the PropertyKeyPath is only for a specific instance. If empty,
+     * it is wildcarded and will match RII RuleIDs property of any instance.*/
+    static PropertyKeyPath GetRIIRuleIDPropertyKeyPath(const InstanceIDType& instanceID = "");
+    /** Returns the property key path for RII DestinationUID properties.
+     * @param instanceID If not empty, the PropertyKeyPath is only for a specific instance. If empty,
+     * it is wildcarded and will match RII DestinationUIDs property of any instance.*/
+    static PropertyKeyPath GetRIIDestinationUIDPropertyKeyPath(const InstanceIDType& instanceID = "");
+
     /** Returns an ID string that identifies the rule class.
     @post The returned rule ID must met the preconditions of a PropertyKeyPath element name
     (see mitk::PropertyKeyPath*/
     virtual RuleIDType GetRuleID() const = 0;
 
     /** Returns a human readable string that can be used to describe the rule. Does not need to be unique.*/
     virtual std::string GetDisplayName() const = 0;
 
     /** Returns a human readable string that can be used to describe the role of a source in context of the rule
      * instance.*/
     virtual std::string GetSourceRoleName() const = 0;
     /** Returns a human readable string that can be used to describe the role of a destionation in context of the rule
      * instance.*/
     virtual std::string GetDestinationRoleName() const = 0;
 
     /** Returns if the instance is a abstract rule (true). Default implementation is true. Overwrite and reimplement
     if another behavior is needed.*/
     virtual bool IsAbstract() const;
 
     /** This method checks if owner is eligible to be a Source for the rule. The default implementation returns a
     True for every valid IPropertyProvider (so only a null_ptr results into false). May be reimplement by derived rules if
     they have requirements on potential Sources).*/
     virtual bool IsSourceCandidate(const IPropertyProvider *owner) const;
 
     /** This method checks if owner is eligible to be a Destination for the rule. The default implementation returns a
     True for every valid IPropertyProvider (so only a null_ptr results into false). May be reimplement by derived rules if
     they have requirements on potential Sources).*/
     virtual bool IsDestinationCandidate(const IPropertyProvider *owner) const;
 
     /** Returns true if the passed owner is a Source of a relation defined by the rule.
     @pre owner must be a pointer to a valid IPropertyProvider instance.*/
     bool IsSource(const IPropertyProvider *owner) const;
 
     /** Returns all relation types of the passed IPropertyOwner instances.
     @remark Abstract rules may have several relationtypes between the instances (from different supported concrete rules), that cover
     both ID and Data relations; thus it returns a vector of RelationTypes.
     @result Vector of all relation types that exist between the given instances. Empty vector equals none relation at all.
     @pre source must be a pointer to a valid IPropertyProvider instance.
     @pre destination must be a pointer to a valid IPropertyProvider instance.
     */
     RelationVectorType GetRelationTypes(const IPropertyProvider* source, const IPropertyProvider* destination) const;
 
     /** Indicates if passed IPropertyOwner instances have a relation of a certain type.
     @remark Abstract rules may also indicate RelationType::Complete if there
     are multiple relations (from different supported concrete rules), that cover
     both ID and Data relations.
     @param requiredRelation Defines the type of relation that should be present. None: does not matter which one, as long as at least one is present.
     Data: Only data layer exclusive connections, ID: Only ID layer exclusive connections. Complete: Only relations that are connected on both layers.
     @pre source must be a pointer to a valid IPropertyProvider instance.
     @pre destination must be a pointer to a valid IPropertyProvider instance.
     */
     bool HasRelation(const IPropertyProvider *source, const IPropertyProvider *destination, RelationType requiredRelation = RelationType::None) const;
 
     /** Returns a vector of relation UIDs for all relations of this rule instance that are defined for
     the passed source.
     @pre source must be a pointer to a valid IPropertyOwner instance.
     @param layer Defines the layer the relations must be reflected. None: does not matter which one, as long as at least one is present.
     Data: Only data layer exclusive connections, ID: Only ID layer exclusive connections. Complete: Only relations that are connected on both layers.*/
     RelationUIDVectorType GetExistingRelations(const IPropertyProvider *source, RelationType layer = RelationType::None) const;
 
     /** Returns the relation UID(s) for the passed source and destination of this rule instance.
     If the rule is abstract multiple relation UIDs might be returned. In case of concrete rule only
     one relation UID.
     @pre source must be a pointer to a valid IPropertyOwner instance.
     @pre destination must be a pointer to a valid IPropertyOwner instance.*/
     RelationUIDVectorType GetRelationUIDs(const IPropertyProvider *source, const IPropertyProvider *destination) const;
 
     /** Returns the relation UID for the passed source and destination of this rule instance.
     If the passed instances have no relation, no ID can be deduced and an exception will be thrown.
     If more than one relation is found, also an exception will be thrown. Thus only use this convenience method,
     if you are sure that one(!) relation UID can exist.
     @pre source must be a pointer to a valid IPropertyOwner instance.
     @pre destination must be a pointer to a valid IPropertyOwner instance.
     @pre Source and destination have one relation; otherwise
     if no relation exists a NoPropertyRelationException is thrown; if more than one relation exists
     a default MITK expception is thrown.*/
     RelationUIDType GetRelationUID(const IPropertyProvider *source, const IPropertyProvider *destination) const;
 
     /**Predicate that can be used to find nodes that qualify as source for that rule (but must not be a source yet).
     Thus all nodes where IsSourceCandidate() returns true. */
     NodePredicateBase::ConstPointer GetSourceCandidateIndicator() const;
     /**Predicate that can be used to find nodes that qualify as destination for that rule (but must not be a destination
     yet). Thus all nodes where IsDestinationCandidate() returns true. */
     NodePredicateBase::ConstPointer GetDestinationCandidateIndicator() const;
     /**Predicate that can be used to find nodes that are Sources of that rule and connected.
     Thus all nodes where IsSource() returns true.*/
     NodePredicateBase::ConstPointer GetConnectedSourcesDetector() const;
     /**Predicate that can be used to find nodes that are as source related to the passed Destination under the rule
     @param destination Pointer to the Destination instance that should be used for detection.
     @param exclusiveRelation Defines if only special types of relations should detected. None: All relations (default);
     Data: must be a data relation (so Data or Complete); ID: must be an ID relation (so ID or Complete); Complete: only complete relations.
     @pre Destination must be a valid instance.*/
     NodePredicateBase::ConstPointer GetSourcesDetector(
       const IPropertyProvider *destination, RelationType exclusiveRelation = RelationType::None) const;
     /**Predicate that can be used to find nodes that are as Destination related to the passed Source under the rule
     @param source Pointer to the Source instance that should be used for detection.
     @param exclusiveRelation Defines if only special types of relations should detected. None: All relations (default);
     Data: must be a data relation (so Data or Complete); ID: must be an ID relation (so ID or Complete); Complete: only complete relations.
     @pre Source must be a valid instance.*/
     NodePredicateBase::ConstPointer GetDestinationsDetector(
       const IPropertyProvider *source, RelationType exclusiveRelation = RelationType::None) const;
     /**Returns a predicate that can be used to find the Destination of the passed Source for a given relationUID.
     @param source Pointer to the Source instance that should be used for detection.
     @pre source must be a valid instance.
     @pre relationUID must identify a relation of the passed source and rule. (This must be in the return of
     this->GetExistingRelations(source). */
     NodePredicateBase::ConstPointer GetDestinationDetector(const IPropertyProvider *source,
                                                            RelationUIDType relationUID) const;
 
     /**Disconnect the passed instances by modifing source. One can specify which layer should be disconnected
     via the argument "layer". Default is the complete disconnection.
     All RII-properties or properties that define the connection on the data layer in the source
     for the passed destination will be removed.
     @pre source must be a valid instance.
     @pre destination must be a valid instance.
     @param layer Defines the way of disconnection. Data: Only the remove the connection on the data layer. ID: Only remove the connection
     on the ID layer. Complete: Remove the connection on all layers. If a connection does not exist on a selected layer, it is silently ignored.*/
     void Disconnect(IPropertyOwner *source, const IPropertyProvider *destination, RelationType layer = RelationType::Complete) const;
     /**Disconnect the source from the passed relationUID (usefull for "zombie relations").
     One can specify which layer should be disconnected
     via the argument "layer". Default is the complete disconnection.
     All RII-properties or properties that define the connection on the data layer in the source
     for the passed destination will be removed.
     If the relationUID is not part of the source. Nothing will be changed.
     @pre source must be a valid instance.
     @param layer Defines the way of disconnection. Data: Only the remove the connection on the data layer. ID: Only remove the connection
     on the ID layer. Complete: Remove the connection on all layers. If a connection does not exist on a selected layer, it is silently ignored.*/
     void Disconnect(IPropertyOwner *source, RelationUIDType relationUID, RelationType layer = RelationType::Complete) const;
 
     /**Returns the list of PropertyKeyPaths of all properties that are relevant for a given relation.
     @param source Pointer to the Source instance that containes the potential properties.
     @param relationUID UID of the relation that is relevant for the requested properties.
     @param layer Indicates which layer is requested. ID: returns all RII properties that belong to the relation. Data: returns all properties that are relevant/belong to the data layer of the relation. Complete: returns all properties (ID+Data)
     @pre source must be a valid instance.
     @pre relationUID must identify a relation of the passed source and rule. (This must be in the return of
     this->GetExistingRelations(source). */
     std::vector<PropertyKeyPath> GetReleationPropertyPaths(const IPropertyProvider* source,
       RelationUIDType relationUID, RelationType layer = RelationType::Data) const;
 
   protected:
     PropertyRelationRuleBase() = default;
     ~PropertyRelationRuleBase() override = default;
 
-    using InstanceIDType = std::string;
     using InstanceIDVectorType = std::vector<InstanceIDType>;
     static InstanceIDType NULL_INSTANCE_ID();
 
     /** Returns the instance IDs for the passed source and destination for this rule instance.
     If the passed source and destination instances has no explicit relation on the ID layer (Connected_ID),
     an empty vector will be returned.
     @remark Per definition of property relation rules only 0 or 1 instance should be found for one provider
     pair and concrete rule. But there might be more then one instanceID because either 1) the rule is abstract and
     supports multiple rule IDs or 2) the data layer may be ambiguous and therefore multiple relation instances of the rule instance
     could match. The implementation of this function should report all relation instances. The calling function
     will take care.
     @pre source must be a pointer to a valid IPropertyProvider instance.
     @pre destination must be a pointer to a valid IPropertyProvider instance.*/
     InstanceIDVectorType GetInstanceID_IDLayer(const IPropertyProvider *source,
                                                                          const IPropertyProvider *destination) const;
 
     using DataRelationUIDVectorType = std::vector< std::pair<RelationUIDType, RuleIDType> >;
     /** Returns the ReleationUIDs of all relations that are defined by the data layer of source for
     this rule instance and, if defined, destination.
     If the passed source (and destination) instance has no relation on the data layer,
     an empty vector will be returned.
     @remark Per definition for property relation rules only 0 or 1 instance should be found for one provider
     pair and concrete rule. But there might be more then one instance because either 1) the rule is abstract and
     supports multiple rule IDs or 2) the data layer may be ambiguous (e.g. because the destination was not specified)
     and therefore multiple relation instances of the rule instance could match.
     The implementation of this function should report all relation instances. The calling function
     will take care.
     @pre source must be a pointer to a valid IPropertyProvider instance.
     @param destination Destination the find relations should point to. If destination is NULL any relation
     on the data layer for this rule and source are wanted.
     @param instances_IDLayer List of releation instances that are already defined by the ID layer. The implementation of this
     function should only cover releations that are not already resembled in the passed relarions_IDLayer.*/
     virtual DataRelationUIDVectorType GetRelationUIDs_DataLayer(const IPropertyProvider * source,
       const IPropertyProvider * destination, const InstanceIDVectorType& instances_IDLayer) const = 0;
 
     /**Helper function that deduces the relation UID of the given relation instance.
     If it cannot be deduced an NoPropertyRelationException is thrown.*/
     RelationUIDType GetRelationUIDByInstanceID(const IPropertyProvider *source, const InstanceIDType &instanceID) const;
     /**Helper function that deduces the relation instance ID given the relation UID.
     If it cannot be deduced an NoPropertyRelationException is thrown.*/
     InstanceIDType GetInstanceIDByRelationUID(const IPropertyProvider *source,
                                               const RelationUIDType &relationUID) const;
 
     /**Explicitly connects the passed instances. Afterwards they have a relation of Data (if data layer is supported), ID (if a
     destination implements IIdentifiable) or Complete (if Data and ID could be connected). If the passed instance are already
     connected the old connection will be overwritten (and raised to the highest possible connection level).
     @remark This method has protected visibility in the base implementation, because it is a design decision of derived rule classes
     which interface they want to offer for connecting. It may just be made public (e.g. GenericIDRelationRule) or used by own implementations.
     @pre source must be a valid instance.
     @pre destination must be a valid instance.
     @pre the rule instance must not be abstract.
     @return Return the relation uid of the relation connected by this method call*/
     RelationUIDType Connect(IPropertyOwner *source, const IPropertyProvider *destination) const;
 
     /**Is called by Connect() to ensure that source has correctly set properties to resemble
     the relation on the data layer. This means that the method should set the properties that describe
     and encode the relation on the data layer (data-layer-specific relation properties).
     If the passed instance are already connected, the old settings should be
     overwritten. Connect() will ensure that source and destination are valid pointers.
     @param instanceID is the ID for the relation instance that should be connected. Existance of the relation instance
     is ensured.
     @pre source must be a valid instance.
     @pre destination must be a valid instance.*/
     virtual void Connect_datalayer(IPropertyOwner *source,
                                    const IPropertyProvider *destination,
                                    const InstanceIDType &instanceID) const = 0;
 
     /**This method is called by Disconnect() to remove all properties of the relation from the source that
     are set by Connect_datalayer().
     @remark This method should remove all properties that are set for a specific relation by Connect_datalayer(...).
     If the relationUID is not part of the source, nothing will be changed. Disconnect() ensures that source is a valid
     pointer if called.
     @remark Disconnect() ensures that sourece is valid and only invokes if instance exists.*/
     virtual void Disconnect_datalayer(IPropertyOwner *source, const RelationUIDType & relationUID) const = 0;
 
     /** Returns if the passed rule ID is supported/relevant for the rule. Either because it is the very ID of the rule (default implementation) or because
     it is an abstract rule which also supports the rule ID.
     @return true: If the rule ID can handle the rule ID. false: the rule does not support the rule ID.*/
     virtual bool IsSupportedRuleID(const RuleIDType& ruleID) const;
 
     /** Helper function that generates a reg ex that can be used to find a specific RII property for the rule instance.
-     * @param propName If not empty a PropertyPath element will added (with the passed value) after the <RuleID> element.
+     * @param propName If not empty a PropertyPath element will added (with the passed value) after the <InstanceID> element.
      * @param instanceID If not empty only for the reg ex will only valid for the passed instanceID. Otherwise for all.*/
     std::string GetRIIPropertyRegEx(const std::string propName = "", const InstanceIDType &instanceID = "") const;
 
     /**Helper function that deduces the instance ID out of a property name.
     If it cannot be deduced an MITK exception is thrown.*/
     static InstanceIDType GetInstanceIDByPropertyName(const std::string propName);
 
     /**Helper function that retrives the rule ID of a relation instance of a passed source.
      @pre source must be valid.
      @pre source must have a relation instance with this ID*/
     RuleIDType GetRuleIDByInstanceID(const IPropertyProvider *source,
       const InstanceIDType &instanceID) const;
     /**Helper function that retrives the destination UID of a relation instance of a passed
        source. If the relation has no destination UID, an empty string will be returned.
        @pre source must be valid.*/
     std::string GetDestinationUIDByInstanceID(const IPropertyProvider * source,
       const InstanceIDType & instanceID) const;
 
     itk::LightObject::Pointer InternalClone() const override;
 
     /** helper method that serves as a workaround until T24729 is done.
        Please remove if T24728 is done then could directly use owner->GetPropertyKeys() again.*/
     static std::vector<std::string> GetPropertyKeys(const IPropertyProvider *owner);
 
     /** Helper method that tries to cast the provider to the Identifiable interface.*/
     const Identifiable* CastProviderAsIdentifiable(const mitk::IPropertyProvider* provider) const;
 
   private:
     /** Creats a relation UID*/
     static RelationUIDType CreateRelationUID();
 
     /**Prepares a new relation instance. Therefore an unused and valid instance ID for the passed source will be genarated
     and a relationUID property with the relationUID will be set to block the instance ID. The
     instance ID will be returned.
     @remark The method is guarded by a class wide mutex to avoid racing conditions in a scenario where rules are used
     concurrently.*/
     InstanceIDType CreateNewRelationInstance(IPropertyOwner *source, const RelationUIDType &relationUID) const;
   };
 
   /**Exception that is used by PropertyRelationRuleBase based classes to indicate that two objects have no relation.*/
   class NoPropertyRelationException : public Exception
   {
   public:
     mitkExceptionClassMacro(NoPropertyRelationException, Exception)
   };
 
 } // namespace mitk
 
 #endif
diff --git a/Modules/Core/src/DataManagement/mitkPropertyRelationRuleBase.cpp b/Modules/Core/src/DataManagement/mitkPropertyRelationRuleBase.cpp
index e05a314b21..cc039919c6 100644
--- a/Modules/Core/src/DataManagement/mitkPropertyRelationRuleBase.cpp
+++ b/Modules/Core/src/DataManagement/mitkPropertyRelationRuleBase.cpp
@@ -1,852 +1,871 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkPropertyRelationRuleBase.h"
 
 #include <mitkDataNode.h>
 #include <mitkExceptionMacro.h>
 #include <mitkNodePredicateBase.h>
 #include <mitkStringProperty.h>
 #include <mitkUIDGenerator.h>
 
 #include <mutex>
 #include <regex>
 #include <algorithm>
 
 bool mitk::PropertyRelationRuleBase::IsAbstract() const
 {
   return true;
 }
 
 bool mitk::PropertyRelationRuleBase::IsSourceCandidate(const IPropertyProvider *owner) const
 {
   return owner != nullptr;
 }
 
 bool mitk::PropertyRelationRuleBase::IsDestinationCandidate(const IPropertyProvider *owner) const
 {
   return owner != nullptr;
 }
 
 mitk::PropertyKeyPath mitk::PropertyRelationRuleBase::GetRootKeyPath()
 {
   return PropertyKeyPath().AddElement("MITK").AddElement("Relations");
 }
 
 bool mitk::PropertyRelationRuleBase::IsSupportedRuleID(const RuleIDType& ruleID) const
 {
   return ruleID == this->GetRuleID();
 }
 
-
-std::string mitk::PropertyRelationRuleBase::GetRIIPropertyRegEx(const std::string propName, const InstanceIDType &instanceID) const
+mitk::PropertyKeyPath mitk::PropertyRelationRuleBase::GetRIIPropertyKeyPath(const std::string propName, const InstanceIDType& instanceID)
 {
-  auto path = this->GetRootKeyPath();
+  auto path = GetRootKeyPath();
   if (instanceID.empty())
   {
     path.AddAnyElement();
   }
   else
   {
     path.AddElement(instanceID);
   }
 
   if (!propName.empty())
   {
     path.AddElement(propName);
   }
 
-  return PropertyKeyPathToPropertyRegEx(path);
+  return path;
+}
+
+std::string mitk::PropertyRelationRuleBase::GetRIIPropertyRegEx(const std::string propName, const InstanceIDType &instanceID) const
+{
+  return PropertyKeyPathToPropertyRegEx(GetRIIPropertyKeyPath(propName, instanceID));
+}
+
+mitk::PropertyKeyPath mitk::PropertyRelationRuleBase::GetRIIRelationUIDPropertyKeyPath(const InstanceIDType& instanceID)
+{
+  return GetRIIPropertyKeyPath("relationUID", instanceID);
+}
+
+mitk::PropertyKeyPath mitk::PropertyRelationRuleBase::GetRIIRuleIDPropertyKeyPath(const InstanceIDType& instanceID)
+{
+  return GetRIIPropertyKeyPath("ruleID", instanceID);
+}
+
+mitk::PropertyKeyPath mitk::PropertyRelationRuleBase::GetRIIDestinationUIDPropertyKeyPath(const InstanceIDType& instanceID)
+{
+  return GetRIIPropertyKeyPath("destinationUID", instanceID);
 }
 
 //workaround until T24729 is done. Please remove if T24728 is done
 //then could directly use owner->GetPropertyKeys() again.
 std::vector<std::string> mitk::PropertyRelationRuleBase::GetPropertyKeys(const mitk::IPropertyProvider *owner)
 {
   std::vector<std::string> keys;
   auto sourceCasted = dynamic_cast<const mitk::DataNode*>(owner);
   if (sourceCasted) {
     auto sourceData = sourceCasted->GetData();
     if (sourceData) {
       keys = sourceData->GetPropertyKeys();
     }
     else {
       keys = sourceCasted->GetPropertyKeys();
     }
   }
   else {
     keys = owner->GetPropertyKeys();
   }
   return keys;
 }
 //end workaround for T24729
 
 bool mitk::PropertyRelationRuleBase::IsSource(const IPropertyProvider *owner) const
 {
   return !this->GetExistingRelations(owner).empty();
 }
 
 bool mitk::PropertyRelationRuleBase::HasRelation(
   const IPropertyProvider* source, const IPropertyProvider* destination, RelationType requiredRelation) const
 {
   auto relTypes = this->GetRelationTypes(source, destination);
 
 
   if (requiredRelation == RelationType::None)
   {
     return !relTypes.empty();
   }
 
   RelationVectorType allowedTypes = { RelationType::Complete };
   if (requiredRelation == RelationType::Data)
   {
     allowedTypes.emplace_back(RelationType::Data);
   }
   else if (requiredRelation == RelationType::ID)
   {
     allowedTypes.emplace_back(RelationType::ID);
   }
 
   return relTypes.end() != std::find_first_of(relTypes.begin(), relTypes.end(), allowedTypes.begin(), allowedTypes.end());
 }
 
 mitk::PropertyRelationRuleBase::RelationVectorType mitk::PropertyRelationRuleBase::GetRelationTypes(
   const IPropertyProvider* source, const IPropertyProvider* destination) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Passed source pointer is NULL";
   }
   if (!destination)
   {
     mitkThrow() << "Error. Passed owner pointer is NULL";
   }
 
   auto instanceIDs_IDLayer = this->GetInstanceID_IDLayer(source, destination);
   auto relIDs_dataLayer = this->GetRelationUIDs_DataLayer(source, destination, {});
   if (relIDs_dataLayer.size() > 1)
   {
     MITK_WARN << "Property relation on data level is ambiguous. First relation is used. Relation UID: "
               << relIDs_dataLayer.front().first;
   }
 
   bool hasComplete = instanceIDs_IDLayer.end() != std::find_if(instanceIDs_IDLayer.begin(), instanceIDs_IDLayer.end(), [&](const InstanceIDVectorType::value_type& instanceID)
   {
     auto relID_IDlayer = this->GetRelationUIDByInstanceID(source, instanceID);
     auto ruleID_IDlayer = this->GetRuleIDByInstanceID(source, instanceID);
 
     return relIDs_dataLayer.end() != std::find_if(relIDs_dataLayer.begin(), relIDs_dataLayer.end(), [&](const DataRelationUIDVectorType::value_type& relID)
     {
       return relID.first == relID_IDlayer && relID.second == ruleID_IDlayer;
     });
   });
 
   bool hasID = instanceIDs_IDLayer.end() != std::find_if(instanceIDs_IDLayer.begin(), instanceIDs_IDLayer.end(), [&](const InstanceIDVectorType::value_type& instanceID)
   {
     auto relID_IDlayer = this->GetRelationUIDByInstanceID(source, instanceID);
     auto ruleID_IDlayer = this->GetRuleIDByInstanceID(source, instanceID);
 
     return relIDs_dataLayer.end() == std::find_if(relIDs_dataLayer.begin(), relIDs_dataLayer.end(), [&](const DataRelationUIDVectorType::value_type& relID)
     {
       return relID.first == relID_IDlayer && relID.second == ruleID_IDlayer;
     });
   });
 
   bool hasData = relIDs_dataLayer.end() != std::find_if(relIDs_dataLayer.begin(), relIDs_dataLayer.end(), [&](const DataRelationUIDVectorType::value_type& relID)
   {
     return instanceIDs_IDLayer.end() == std::find_if(instanceIDs_IDLayer.begin(), instanceIDs_IDLayer.end(), [&](const InstanceIDVectorType::value_type& instanceID)
     {
       auto relID_IDlayer = this->GetRelationUIDByInstanceID(source, instanceID);
       auto ruleID_IDlayer = this->GetRuleIDByInstanceID(source, instanceID);
       return relID.first == relID_IDlayer && relID.second == ruleID_IDlayer;
     });
   });
 
   RelationVectorType result;
 
   if (hasData)
   {
     result.emplace_back(RelationType::Data);
   }
   if (hasID)
   {
     result.emplace_back(RelationType::ID);
   }
   if (hasComplete)
   {
     result.emplace_back(RelationType::Complete);
   }
 
   return result;
 }
 
 mitk::PropertyRelationRuleBase::RelationUIDVectorType mitk::PropertyRelationRuleBase::GetExistingRelations(
   const IPropertyProvider *source, RelationType layer) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Passed source pointer is NULL";
   }
 
   RelationUIDVectorType relationUIDs;
   InstanceIDVectorType instanceIDs;
 
   if (layer != RelationType::Data)
   {
     auto ruleIDRegExStr = this->GetRIIPropertyRegEx("ruleID");
     auto regEx = std::regex(ruleIDRegExStr);
 
     //workaround until T24729 is done. You can use directly source->GetPropertyKeys again, when fixed.
     const auto keys = GetPropertyKeys(source);
     //end workaround for T24729
 
     for (const auto& key : keys)
     {
       if (std::regex_match(key, regEx))
       {
         auto idProp = source->GetConstProperty(key);
         auto ruleID = idProp->GetValueAsString();
         if (this->IsSupportedRuleID(ruleID))
         {
           auto instanceID = this->GetInstanceIDByPropertyName(key);
           instanceIDs.emplace_back(instanceID);
           relationUIDs.push_back(this->GetRelationUIDByInstanceID(source, instanceID));
         }
       }
     }
   }
 
   if (layer == RelationType::ID)
   {
     return relationUIDs;
   }
 
   DataRelationUIDVectorType relationUIDandRuleID_Data;
   if (layer != RelationType::ID)
   {
     relationUIDandRuleID_Data = this->GetRelationUIDs_DataLayer(source, nullptr, instanceIDs);
   }
 
   RelationUIDVectorType relationUIDs_Data;
   std::transform(relationUIDandRuleID_Data.begin(), relationUIDandRuleID_Data.end(), std::back_inserter(relationUIDs_Data),
     [](const DataRelationUIDVectorType::value_type& v) { return v.first; });
 
   if (layer == RelationType::Data)
   {
     return relationUIDs_Data;
   }
 
   std::sort(relationUIDs.begin(), relationUIDs.end());
   std::sort(relationUIDs_Data.begin(), relationUIDs_Data.end());
 
   RelationUIDVectorType result;
 
   if (layer == RelationType::Complete)
   {
     std::set_intersection(relationUIDs.begin(), relationUIDs.end(), relationUIDs_Data.begin(), relationUIDs_Data.end(), std::back_inserter(result));
   }
   else
   {
     std::set_union(relationUIDs.begin(), relationUIDs.end(), relationUIDs_Data.begin(), relationUIDs_Data.end(), std::back_inserter(result));
   }
 
   return result;
 }
 
 mitk::PropertyRelationRuleBase::RelationUIDVectorType mitk::PropertyRelationRuleBase::GetRelationUIDs(
   const IPropertyProvider *source, const IPropertyProvider *destination) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Passed source pointer is NULL";
   }
   if (!destination)
   {
     mitkThrow() << "Error. Passed destination pointer is NULL";
   }
 
   RelationUIDVectorType relUIDs_id;
 
   auto instanceIDs = this->GetInstanceID_IDLayer(source, destination);
   for (const auto instanceID : instanceIDs)
   {
     relUIDs_id.push_back(this->GetRelationUIDByInstanceID(source, instanceID));
   }
 
   DataRelationUIDVectorType relationUIDandRuleID_Data = this->GetRelationUIDs_DataLayer(source,destination,instanceIDs);
   RelationUIDVectorType relUIDs_Data;
   std::transform(relationUIDandRuleID_Data.begin(), relationUIDandRuleID_Data.end(), std::back_inserter(relUIDs_Data),
     [](const DataRelationUIDVectorType::value_type& v) { return v.first; });
 
   std::sort(relUIDs_id.begin(), relUIDs_id.end());
   std::sort(relUIDs_Data.begin(), relUIDs_Data.end());
 
   RelationUIDVectorType result;
   std::set_union(relUIDs_id.begin(), relUIDs_id.end(), relUIDs_Data.begin(), relUIDs_Data.end(), std::back_inserter(result));
 
   return result;
 }
 
 mitk::PropertyRelationRuleBase::RelationUIDType
 mitk::PropertyRelationRuleBase::GetRelationUID(const IPropertyProvider *source, const IPropertyProvider *destination) const
 {
   auto result = this->GetRelationUIDs(source, destination);
 
   if (result.empty())
   {
     mitkThrowException(NoPropertyRelationException);
   }
   else if(result.size()>1)
   {
     mitkThrow() << "Cannot return one(!) relation UID. Multiple relations exists for given rule, source and destination.";
   }
 
   return result[0];
 }
 
 mitk::PropertyRelationRuleBase::InstanceIDType mitk::PropertyRelationRuleBase::NULL_INSTANCE_ID()
 {
   return std::string();
 };
 
 mitk::PropertyRelationRuleBase::RelationUIDType mitk::PropertyRelationRuleBase::GetRelationUIDByInstanceID(
   const IPropertyProvider *source, const InstanceIDType &instanceID) const
 {
   RelationUIDType result;
 
   if (instanceID != NULL_INSTANCE_ID())
   {
     auto idProp = source->GetConstProperty(
-      PropertyKeyPathToPropertyName(this->GetRootKeyPath().AddElement(instanceID).AddElement("relationUID")));
+      PropertyKeyPathToPropertyName(GetRIIRelationUIDPropertyKeyPath(instanceID)));
 
     if (idProp.IsNotNull())
     {
       result = idProp->GetValueAsString();
     }
   }
 
   if (result.empty())
   {
     mitkThrowException(NoPropertyRelationException);
   }
 
   return result;
 }
 
 mitk::PropertyRelationRuleBase::InstanceIDType mitk::PropertyRelationRuleBase::GetInstanceIDByRelationUID(
   const IPropertyProvider *source, const RelationUIDType &relationUID) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Passed source pointer is NULL";
   }
 
   InstanceIDType result = NULL_INSTANCE_ID();
 
   auto destRegExStr =
-    PropertyKeyPathToPropertyRegEx(GetRootKeyPath().AddAnyElement().AddElement("relationUID"));
+    PropertyKeyPathToPropertyRegEx(GetRIIRelationUIDPropertyKeyPath());
   auto regEx = std::regex(destRegExStr);
   std::smatch instance_matches;
 
   //workaround until T24729 is done. You can use directly source->GetPropertyKeys again, when fixed.
   const auto keys = GetPropertyKeys(source);
   //end workaround for T24729
 
   for (const auto &key : keys)
   {
     if (std::regex_search(key, instance_matches, regEx))
     {
       auto idProp = source->GetConstProperty(key);
       if (idProp->GetValueAsString() == relationUID)
       {
         if (instance_matches.size()>1)
         {
           result = instance_matches[1];
           break;
         }
       }
     }
   }
 
   return result;
 }
 
 mitk::PropertyRelationRuleBase::InstanceIDVectorType mitk::PropertyRelationRuleBase::GetInstanceID_IDLayer(
   const IPropertyProvider *source, const IPropertyProvider *destination) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Passed source pointer is NULL";
   }
   if (!destination)
   {
     mitkThrow() << "Error. Passed destination pointer is NULL";
   }
 
   auto identifiable = CastProviderAsIdentifiable(destination);
 
   InstanceIDVectorType result;
 
   if (identifiable)
   { // check for relations of type Connected_ID;
 
     auto destRegExStr = this->GetRIIPropertyRegEx("destinationUID");
     auto regEx = std::regex(destRegExStr);
     std::smatch instance_matches;
 
     auto destUID = identifiable->GetUID();
 
     //workaround until T24729 is done. You can use directly source->GetPropertyKeys again, when fixed.
     const auto keys = GetPropertyKeys(source);
     //end workaround for T24729
 
     for (const auto &key : keys)
     {
       if (std::regex_search(key, instance_matches, regEx))
       {
         auto idProp = source->GetConstProperty(key);
         if (idProp->GetValueAsString() == destUID)
         {
           if (instance_matches.size()>1)
           {
             auto instanceID = instance_matches[1];
             if (this->IsSupportedRuleID(GetRuleIDByInstanceID(source, instanceID)))
             {
               result.push_back(instanceID);
             }
           }
         }
       }
     }
   }
 
   return result;
 }
 
 const mitk::Identifiable* mitk::PropertyRelationRuleBase::CastProviderAsIdentifiable(const mitk::IPropertyProvider* destination) const
 {
   auto identifiable = dynamic_cast<const Identifiable*>(destination);
 
   if (!identifiable)
   { //This check and pass through to data is needed due to solve T25711. See Task for more information.
     //This could be removed at the point we can get rid of DataNodes or they get realy transparent.
     auto node = dynamic_cast<const DataNode*>(destination);
     if (node && node->GetData())
     {
       identifiable = dynamic_cast<const Identifiable*>(node->GetData());
     }
   }
 
   return identifiable;
 }
 
 mitk::PropertyRelationRuleBase::RelationUIDType mitk::PropertyRelationRuleBase::Connect(IPropertyOwner *source, const IPropertyProvider *destination) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Passed source pointer is NULL";
   }
   if (!destination)
   {
     mitkThrow() << "Error. Passed destination pointer is NULL";
   }
   if (this->IsAbstract())
   {
     mitkThrow() << "Error. This is an abstract property relation rule. Abstract rule must not make a connection. Please use a concrete rule.";
   }
 
   auto instanceIDs = this->GetInstanceID_IDLayer(source, destination);
   bool hasIDlayer = !instanceIDs.empty();
 
   auto relUIDs_data = this->GetRelationUIDs_DataLayer(source, destination, {});
 
   if (relUIDs_data.size() > 1)
   {
     MITK_WARN << "Property relation on data level is ambiguous. First relation is used. RelationUID ID: "
               << relUIDs_data.front().first;
   }
 
   bool hasDatalayer = !relUIDs_data.empty();
 
   RelationUIDType relationUID = this->CreateRelationUID();
 
   InstanceIDType instanceID = NULL_INSTANCE_ID();
 
   if (hasIDlayer)
   {
     instanceID = instanceIDs.front();
   }
   else if (hasDatalayer)
   {
     try
     {
       instanceID = this->GetInstanceIDByRelationUID(source, relUIDs_data.front().first);
     }
     catch(...)
     { }
   }
 
   if(instanceID == NULL_INSTANCE_ID())
   {
     instanceID = this->CreateNewRelationInstance(source, relationUID);
   }
 
   auto relUIDKey =
-    PropertyKeyPathToPropertyName(GetRootKeyPath().AddElement(instanceID).AddElement("relationUID"));
+    PropertyKeyPathToPropertyName(GetRIIRelationUIDPropertyKeyPath(instanceID));
   source->SetProperty(relUIDKey, mitk::StringProperty::New(relationUID));
 
   auto ruleIDKey =
-    PropertyKeyPathToPropertyName(GetRootKeyPath().AddElement(instanceID).AddElement("ruleID"));
+    PropertyKeyPathToPropertyName(GetRIIRuleIDPropertyKeyPath(instanceID));
   source->SetProperty(ruleIDKey, mitk::StringProperty::New(this->GetRuleID()));
 
   if (!hasIDlayer)
   {
     auto identifiable = this->CastProviderAsIdentifiable(destination);
 
     if (identifiable)
     {
       auto destUIDKey =
-        PropertyKeyPathToPropertyName(GetRootKeyPath().AddElement(instanceID).AddElement("destinationUID"));
+        PropertyKeyPathToPropertyName(GetRIIDestinationUIDPropertyKeyPath(instanceID));
       source->SetProperty(destUIDKey, mitk::StringProperty::New(identifiable->GetUID()));
     }
   }
 
   this->Connect_datalayer(source, destination, instanceID);
 
   return relationUID;
 }
 
 void mitk::PropertyRelationRuleBase::Disconnect(IPropertyOwner *source, const IPropertyProvider *destination, RelationType layer) const
 {
   if (source == nullptr)
   {
     mitkThrow() << "Error. Source is invalid. Cannot disconnect.";
   }
 
   if (destination == nullptr)
   {
     mitkThrow() << "Error. Destination is invalid. Cannot disconnect.";
   }
 
   try
   {
     const auto relationUIDs = this->GetRelationUIDs(source, destination);
     for (const auto relUID: relationUIDs)
     {
       this->Disconnect(source, relUID, layer);
     }
   }
   catch (const NoPropertyRelationException &)
   {
     // nothing to do and no real error in context of disconnect.
   }
 }
 
 void mitk::PropertyRelationRuleBase::Disconnect(IPropertyOwner *source, RelationUIDType relationUID, RelationType layer) const
 {
   if (source == nullptr)
   {
     mitkThrow() << "Error. Source is invalid. Cannot disconnect.";
   }
 
   if (layer == RelationType::Data || layer == RelationType::Complete)
   {
     this->Disconnect_datalayer(source, relationUID);
   }
 
   auto instanceID = this->GetInstanceIDByRelationUID(source, relationUID);
   if ((layer == RelationType::ID || layer == RelationType::Complete) && instanceID != NULL_INSTANCE_ID())
   {
     auto instancePrefix = PropertyKeyPathToPropertyName(GetRootKeyPath().AddElement(instanceID));
 
     //workaround until T24729 is done. You can use directly source->GetPropertyKeys again, when fixed.
     const auto keys = GetPropertyKeys(source);
     //end workaround for T24729
 
 
     for (const auto &key : keys)
     {
       if (key.find(instancePrefix) == 0)
       {
         source->RemoveProperty(key);
       }
     }
   }
 }
 
 mitk::PropertyRelationRuleBase::RelationUIDType mitk::PropertyRelationRuleBase::CreateRelationUID()
 {
   UIDGenerator generator;
   return generator.GetUID();
 }
 
 /**This mutex is used to guard mitk::PropertyRelationRuleBase::CreateNewRelationInstance by a class wide mutex to avoid
   racing conditions in a scenario where rules are used concurrently. It is not in the class interface itself, because it
   is an implementation detail.
 */
 std::mutex relationCreationLock;
 
 mitk::PropertyRelationRuleBase::InstanceIDType mitk::PropertyRelationRuleBase::CreateNewRelationInstance(
   IPropertyOwner *source, const RelationUIDType &relationUID) const
 {
   std::lock_guard<std::mutex> guard(relationCreationLock);
 
   //////////////////////////////////////
   // Get all existing instanc IDs
 
   std::vector<int> instanceIDs;
   InstanceIDType newID = "1";
 
   auto destRegExStr =
-    PropertyKeyPathToPropertyRegEx(this->GetRootKeyPath().AddAnyElement().AddElement("relationUID"));
+    PropertyKeyPathToPropertyRegEx(GetRIIRelationUIDPropertyKeyPath());
   auto regEx = std::regex(destRegExStr);
   std::smatch instance_matches;
 
   //workaround until T24729 is done. You can use directly source->GetPropertyKeys again, when fixed.
   const auto keys = GetPropertyKeys(source);
   //end workaround for T24729
 
 
   for (const auto &key : keys)
   {
     if (std::regex_search(key, instance_matches, regEx))
     {
       if (instance_matches.size()>1)
       {
         instanceIDs.push_back(std::stoi(instance_matches[1]));
       }
     }
   }
 
   //////////////////////////////////////
   // Get new ID
 
   std::sort(instanceIDs.begin(), instanceIDs.end());
   if (!instanceIDs.empty())
   {
     newID = std::to_string(instanceIDs.back() + 1);
   }
 
   //////////////////////////////////////
   // reserve new ID
   auto relUIDKey =
-    PropertyKeyPathToPropertyName(this->GetRootKeyPath().AddElement(newID).AddElement("relationUID"));
+    PropertyKeyPathToPropertyName(GetRIIRelationUIDPropertyKeyPath(newID));
   source->SetProperty(relUIDKey, mitk::StringProperty::New(relationUID));
 
   return newID;
 }
 
 itk::LightObject::Pointer mitk::PropertyRelationRuleBase::InternalClone() const
 {
   return Superclass::InternalClone();
 }
 
 
 mitk::PropertyRelationRuleBase::InstanceIDType mitk::PropertyRelationRuleBase::GetInstanceIDByPropertyName(const std::string propName)
 {
   auto proppath = PropertyNameToPropertyKeyPath(propName);
   auto ref = GetRootKeyPath();
 
   if (proppath.GetSize() < 3 || !(proppath.GetFirstNode() == ref.GetFirstNode()) || !(proppath.GetNode(1) == ref.GetNode(1)))
   {
     mitkThrow() << "Property name is not for a RII property or containes no instance ID. Wrong name: " << propName;
   }
 
   return proppath.GetNode(2).name;
 }
 
 mitk::PropertyRelationRuleBase::RuleIDType mitk::PropertyRelationRuleBase::GetRuleIDByInstanceID(const IPropertyProvider *source,
   const InstanceIDType &instanceID) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Source is invalid. Cannot deduce rule ID";
   }
 
-  auto path = GetRootKeyPath().AddElement(instanceID).AddElement("ruleID");
+  auto path = GetRIIRuleIDPropertyKeyPath(instanceID);
   auto name = PropertyKeyPathToPropertyName(path);
 
   const auto prop = source->GetConstProperty(name);
 
   std::string result;
 
  if (prop.IsNotNull())
  {
    result = prop->GetValueAsString();
  }
 
   if (result.empty())
   {
     mitkThrowException(NoPropertyRelationException) << "Error. Source has no property relation with the passed instance ID. Instance ID: " << instanceID;
   }
 
   return result;
 }
 
 std::string mitk::PropertyRelationRuleBase::GetDestinationUIDByInstanceID(const IPropertyProvider* source,
   const InstanceIDType& instanceID) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Source is invalid. Cannot deduce rule ID";
   }
 
-  auto path = GetRootKeyPath().AddElement(instanceID).AddElement("destinationUID");
+  auto path = GetRIIDestinationUIDPropertyKeyPath(instanceID);
   auto name = PropertyKeyPathToPropertyName(path);
 
   const auto prop = source->GetConstProperty(name);
 
   std::string result;
 
   if (prop.IsNotNull())
   {
     result = prop->GetValueAsString();
   }
 
   return result;
 }
 
 
 namespace mitk
 {
   /**
   * \brief Predicate used to wrap rule checks.
   *
   * \ingroup DataStorage
   */
   class NodePredicateRuleFunction : public NodePredicateBase
   {
   public:
     using FunctionType = std::function<bool(const mitk::IPropertyProvider *, const mitk::PropertyRelationRuleBase *)>;
 
     mitkClassMacro(NodePredicateRuleFunction, NodePredicateBase)
       mitkNewMacro2Param(NodePredicateRuleFunction, const FunctionType &, PropertyRelationRuleBase::ConstPointer)
 
     ~NodePredicateRuleFunction() override = default;
 
     bool CheckNode(const mitk::DataNode *node) const override
     {
       if (!node)
       {
         return false;
       }
 
       return m_Function(node, m_Rule);
     };
 
   protected:
     explicit NodePredicateRuleFunction(const FunctionType &function, PropertyRelationRuleBase::ConstPointer rule) : m_Function(function), m_Rule(rule)
     {
     };
 
     FunctionType m_Function;
     PropertyRelationRuleBase::ConstPointer m_Rule;
   };
 
 } // namespace mitk
 
 mitk::NodePredicateBase::ConstPointer mitk::PropertyRelationRuleBase::GetSourceCandidateIndicator() const
 {
   auto check = [](const mitk::IPropertyProvider *node, const mitk::PropertyRelationRuleBase *rule) {
     return rule->IsSourceCandidate(node);
   };
 
   return NodePredicateRuleFunction::New(check, this).GetPointer();
 }
 
 mitk::NodePredicateBase::ConstPointer mitk::PropertyRelationRuleBase::GetDestinationCandidateIndicator() const
 {
   auto check = [](const mitk::IPropertyProvider *node, const mitk::PropertyRelationRuleBase *rule) {
     return rule->IsDestinationCandidate(node);
   };
 
   return NodePredicateRuleFunction::New(check, this).GetPointer();
 }
 
 mitk::NodePredicateBase::ConstPointer mitk::PropertyRelationRuleBase::GetConnectedSourcesDetector() const
 {
   auto check = [](const mitk::IPropertyProvider *node, const mitk::PropertyRelationRuleBase *rule)
   {
     return rule->IsSource(node);
   };
 
   return NodePredicateRuleFunction::New(check, this).GetPointer();
 }
 
 mitk::NodePredicateBase::ConstPointer mitk::PropertyRelationRuleBase::GetSourcesDetector(
   const IPropertyProvider *destination, RelationType exclusiveRelation) const
 {
   if (!destination)
   {
     mitkThrow() << "Error. Passed destination pointer is NULL";
   }
 
   auto check = [destination, exclusiveRelation](const mitk::IPropertyProvider *node,
                                               const mitk::PropertyRelationRuleBase *rule) {
     return rule->HasRelation(node, destination, exclusiveRelation);
   };
 
   return NodePredicateRuleFunction::New(check, this).GetPointer();
 }
 
 mitk::NodePredicateBase::ConstPointer mitk::PropertyRelationRuleBase::GetDestinationsDetector(
   const IPropertyProvider *source, RelationType exclusiveRelation) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Passed source pointer is NULL";
   }
 
   auto check = [source, exclusiveRelation](const mitk::IPropertyProvider *node,
                                          const mitk::PropertyRelationRuleBase *rule) {
     return rule->HasRelation(source, node, exclusiveRelation);
   };
 
   return NodePredicateRuleFunction::New(check, this).GetPointer();
 }
 
 mitk::NodePredicateBase::ConstPointer mitk::PropertyRelationRuleBase::GetDestinationDetector(
   const IPropertyProvider *source, RelationUIDType relationUID) const
 {
   if (!source)
   {
     mitkThrow() << "Error. Passed source pointer is NULL";
   }
 
   auto relUIDs = this->GetExistingRelations(source);
   if (std::find(relUIDs.begin(), relUIDs.end(), relationUID) == relUIDs.end())
   {
     mitkThrow()
       << "Error. Passed relationUID does not identify a relation instance of the passed source for this rule instance.";
   };
 
   auto check = [source, relationUID](const mitk::IPropertyProvider *node, const mitk::PropertyRelationRuleBase *rule) {
     try
     {
       auto relevantUIDs = rule->GetRelationUIDs(source, node);
       for (const auto& aUID : relevantUIDs)
       {
         if (aUID == relationUID)
         {
           return true;
         }
       }
     }
     catch(const NoPropertyRelationException &)
     {
       return false;
     }
     return false;
   };
 
   return NodePredicateRuleFunction::New(check, this).GetPointer();
 }
diff --git a/Modules/Core/src/mitkCoreActivator.cpp b/Modules/Core/src/mitkCoreActivator.cpp
index 4e2a3363d9..54bd9a77b8 100644
--- a/Modules/Core/src/mitkCoreActivator.cpp
+++ b/Modules/Core/src/mitkCoreActivator.cpp
@@ -1,357 +1,365 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkCoreActivator.h"
 
 #include <mitkCoreServices.h>
 #include <mitkPropertyPersistenceInfo.h>
 
 // File IO
 #include <mitkIOMetaInformationPropertyConstants.h>
 #include <mitkGeometryDataReaderService.h>
 #include <mitkGeometryDataWriterService.h>
 #include <mitkIOMimeTypes.h>
 #include <mitkIOUtil.h>
 #include <mitkImageVtkLegacyIO.h>
 #include <mitkImageVtkXmlIO.h>
 #include <mitkItkImageIO.h>
 #include <mitkMimeTypeProvider.h>
 #include <mitkPointSetReaderService.h>
 #include <mitkPointSetWriterService.h>
 #include <mitkRawImageFileReader.h>
 #include <mitkSurfaceStlIO.h>
 #include <mitkSurfaceVtkLegacyIO.h>
 #include <mitkSurfaceVtkXmlIO.h>
 
 #include "mitkLegacyFileWriterService.h"
 #include <mitkFileWriter.h>
 
 #include <itkGDCMImageIO.h>
 #include <itkNiftiImageIO.h>
 
+// PropertyRelationRules
+#include <mitkPropertyRelationRuleBase.h>
+
 // Micro Services
 #include <usGetModuleContext.h>
 #include <usModule.h>
 #include <usModuleActivator.h>
 #include <usModuleContext.h>
 #include <usModuleEvent.h>
 #include <usModuleInitialization.h>
 #include <usModuleResource.h>
 #include <usModuleResourceStream.h>
 #include <usModuleSettings.h>
 #include <usServiceTracker.h>
 
 // ITK "injects" static initialization code for IO factories
 // via the itkImageIOFactoryRegisterManager.h header (which
 // is generated in the application library build directory).
 // To ensure that the code is called *before* the CppMicroServices
 // static initialization code (which triggers the Activator::Start
 // method), we include the ITK header here.
 #include <itkImageIOFactoryRegisterManager.h>
 
 void HandleMicroServicesMessages(us::MsgType type, const char *msg)
 {
   switch (type)
   {
     case us::DebugMsg:
       MITK_DEBUG << msg;
       break;
     case us::InfoMsg:
       MITK_INFO << msg;
       break;
     case us::WarningMsg:
       MITK_WARN << msg;
       break;
     case us::ErrorMsg:
       MITK_ERROR << msg;
       break;
   }
 }
 
 void AddMitkAutoLoadPaths(const std::string &programPath)
 {
   us::ModuleSettings::AddAutoLoadPath(programPath);
 #ifdef __APPLE__
   // Walk up three directories since that is where the .dylib files are located
   // for build trees.
   std::string additionalPath = programPath;
   bool addPath = true;
   for (int i = 0; i < 3; ++i)
   {
     std::size_t index = additionalPath.find_last_of('/');
     if (index != std::string::npos)
     {
       additionalPath = additionalPath.substr(0, index);
     }
     else
     {
       addPath = false;
       break;
     }
   }
   if (addPath)
   {
     us::ModuleSettings::AddAutoLoadPath(additionalPath);
   }
 #endif
 }
 
 void AddPropertyPersistence(const mitk::PropertyKeyPath& propPath)
 {
   mitk::CoreServicePointer<mitk::IPropertyPersistence> persistenceService(mitk::CoreServices::GetPropertyPersistence());
 
   auto info = mitk::PropertyPersistenceInfo::New();
   if (propPath.IsExplicit())
   {
     std::string name = mitk::PropertyKeyPathToPropertyName(propPath);
     std::string key = name;
     std::replace(key.begin(), key.end(), '.', '_');
     info->SetNameAndKey(name, key);
   }
   else
   {
     std::string key = mitk::PropertyKeyPathToPersistenceKeyRegEx(propPath);
     std::string keyTemplate = mitk::PropertyKeyPathToPersistenceKeyTemplate(propPath);
     std::string propRegEx = mitk::PropertyKeyPathToPropertyRegEx(propPath);
     std::string propTemplate = mitk::PropertyKeyPathToPersistenceNameTemplate(propPath);
     info->UseRegEx(propRegEx, propTemplate, key, keyTemplate);
   }
 
   persistenceService->AddInfo(info);
 }
 
 class FixedNiftiImageIO : public itk::NiftiImageIO
 {
 public:
   /** Standard class typedefs. */
   typedef FixedNiftiImageIO Self;
   typedef itk::NiftiImageIO Superclass;
   typedef itk::SmartPointer<Self> Pointer;
 
   /** Method for creation through the object factory. */
   itkNewMacro(Self)
 
     /** Run-time type information (and related methods). */
     itkTypeMacro(FixedNiftiImageIO, Superclass)
 
       bool SupportsDimension(unsigned long dim) override
   {
     return dim > 1 && dim < 5;
   }
 };
 
 void MitkCoreActivator::Load(us::ModuleContext *context)
 {
   // Handle messages from CppMicroServices
   us::installMsgHandler(HandleMicroServicesMessages);
 
   this->m_Context = context;
 
   // Add the current application directory to the auto-load paths.
   // This is useful for third-party executables.
   std::string programPath = mitk::IOUtil::GetProgramPath();
   if (programPath.empty())
   {
     MITK_WARN << "Could not get the program path.";
   }
   else
   {
     AddMitkAutoLoadPaths(programPath);
   }
 
   // m_RenderingManager = mitk::RenderingManager::New();
   // context->RegisterService<mitk::RenderingManager>(renderingManager.GetPointer());
   m_PlanePositionManager.reset(new mitk::PlanePositionManagerService);
   context->RegisterService<mitk::PlanePositionManagerService>(m_PlanePositionManager.get());
 
   m_PropertyAliases.reset(new mitk::PropertyAliases);
   context->RegisterService<mitk::IPropertyAliases>(m_PropertyAliases.get());
 
   m_PropertyDescriptions.reset(new mitk::PropertyDescriptions);
   context->RegisterService<mitk::IPropertyDescriptions>(m_PropertyDescriptions.get());
 
   m_PropertyExtensions.reset(new mitk::PropertyExtensions);
   context->RegisterService<mitk::IPropertyExtensions>(m_PropertyExtensions.get());
 
   m_PropertyFilters.reset(new mitk::PropertyFilters);
   context->RegisterService<mitk::IPropertyFilters>(m_PropertyFilters.get());
 
   m_PropertyPersistence.reset(new mitk::PropertyPersistence);
   context->RegisterService<mitk::IPropertyPersistence>(m_PropertyPersistence.get());
 
   m_PropertyRelations.reset(new mitk::PropertyRelations);
   context->RegisterService<mitk::IPropertyRelations>(m_PropertyRelations.get());
 
   m_MimeTypeProvider.reset(new mitk::MimeTypeProvider);
   m_MimeTypeProvider->Start();
   m_MimeTypeProviderReg = context->RegisterService<mitk::IMimeTypeProvider>(m_MimeTypeProvider.get());
 
   this->RegisterDefaultMimeTypes();
   this->RegisterItkReaderWriter();
   this->RegisterVtkReaderWriter();
 
   // Add custom Reader / Writer Services
   m_FileReaders.push_back(new mitk::PointSetReaderService());
   m_FileWriters.push_back(new mitk::PointSetWriterService());
   m_FileReaders.push_back(new mitk::GeometryDataReaderService());
   m_FileWriters.push_back(new mitk::GeometryDataWriterService());
   m_FileReaders.push_back(new mitk::RawImageFileReaderService());
 
   //add properties that should be persistent (if possible/supported by the writer)
   AddPropertyPersistence(mitk::IOMetaInformationPropertyConstants::READER_DESCRIPTION());
   AddPropertyPersistence(mitk::IOMetaInformationPropertyConstants::READER_INPUTLOCATION());
   AddPropertyPersistence(mitk::IOMetaInformationPropertyConstants::READER_MIME_CATEGORY());
   AddPropertyPersistence(mitk::IOMetaInformationPropertyConstants::READER_MIME_NAME());
   AddPropertyPersistence(mitk::IOMetaInformationPropertyConstants::READER_VERSION());
   AddPropertyPersistence(mitk::IOMetaInformationPropertyConstants::READER_OPTIONS_ANY());
 
+  AddPropertyPersistence(mitk::PropertyRelationRuleBase::GetRIIDestinationUIDPropertyKeyPath());
+  AddPropertyPersistence(mitk::PropertyRelationRuleBase::GetRIIRelationUIDPropertyKeyPath());
+  AddPropertyPersistence(mitk::PropertyRelationRuleBase::GetRIIRuleIDPropertyKeyPath());
+  AddPropertyPersistence(mitk::PropertyRelationRuleBase::GetRIIPropertyKeyPath("","").AddAnyElement());
+
   /*
     There IS an option to exchange ALL vtkTexture instances against vtkNeverTranslucentTextureFactory.
     This code is left here as a reminder, just in case we might need to do that some time.
 
     vtkNeverTranslucentTextureFactory* textureFactory = vtkNeverTranslucentTextureFactory::New();
     vtkObjectFactory::RegisterFactory( textureFactory );
     textureFactory->Delete();
     */
 
   this->RegisterLegacyWriter();
 }
 
 void MitkCoreActivator::Unload(us::ModuleContext *)
 {
   for (auto &elem : m_FileReaders)
   {
     delete elem;
   }
 
   for (auto &elem : m_FileWriters)
   {
     delete elem;
   }
 
   for (auto &elem : m_FileIOs)
   {
     delete elem;
   }
 
   for (auto &elem : m_LegacyWriters)
   {
     delete elem;
   }
 
   // The mitk::ModuleContext* argument of the Unload() method
   // will always be 0 for the Mitk library. It makes no sense
   // to use it at this stage anyway, since all libraries which
   // know about the module system have already been unloaded.
 
   // we need to close the internal service tracker of the
   // MimeTypeProvider class here. Otherwise it
   // would hold on to the ModuleContext longer than it is
   // actually valid.
   m_MimeTypeProviderReg.Unregister();
   m_MimeTypeProvider->Stop();
 
   for (std::vector<mitk::CustomMimeType *>::const_iterator mimeTypeIter = m_DefaultMimeTypes.begin(),
                                                            iterEnd = m_DefaultMimeTypes.end();
        mimeTypeIter != iterEnd;
        ++mimeTypeIter)
   {
     delete *mimeTypeIter;
   }
 }
 
 void MitkCoreActivator::RegisterDefaultMimeTypes()
 {
   // Register some default mime-types
 
   std::vector<mitk::CustomMimeType *> mimeTypes = mitk::IOMimeTypes::Get();
   for (std::vector<mitk::CustomMimeType *>::const_iterator mimeTypeIter = mimeTypes.begin(), iterEnd = mimeTypes.end();
        mimeTypeIter != iterEnd;
        ++mimeTypeIter)
   {
     m_DefaultMimeTypes.push_back(*mimeTypeIter);
     m_Context->RegisterService(m_DefaultMimeTypes.back());
   }
 }
 
 void MitkCoreActivator::RegisterItkReaderWriter()
 {
   std::list<itk::LightObject::Pointer> allobjects = itk::ObjectFactoryBase::CreateAllInstance("itkImageIOBase");
 
   for (auto &allobject : allobjects)
   {
     auto *io = dynamic_cast<itk::ImageIOBase *>(allobject.GetPointer());
 
     // NiftiImageIO does not provide a correct "SupportsDimension()" methods
     // and the supported read/write extensions are not ordered correctly
     if (dynamic_cast<itk::NiftiImageIO *>(io))
       continue;
 
     // Use a custom mime-type for GDCMImageIO below
     if (dynamic_cast<itk::GDCMImageIO *>(allobject.GetPointer()))
     {
       // MITK provides its own DICOM reader (which internally uses GDCMImageIO).
       continue;
     }
 
     if (io)
     {
       m_FileIOs.push_back(new mitk::ItkImageIO(io));
     }
     else
     {
       MITK_WARN << "Error ImageIO factory did not return an ImageIOBase: " << (allobject)->GetNameOfClass();
     }
   }
 
   FixedNiftiImageIO::Pointer itkNiftiIO = FixedNiftiImageIO::New();
   mitk::ItkImageIO *niftiIO = new mitk::ItkImageIO(mitk::IOMimeTypes::NIFTI_MIMETYPE(), itkNiftiIO.GetPointer(), 0);
   m_FileIOs.push_back(niftiIO);
 }
 
 void MitkCoreActivator::RegisterVtkReaderWriter()
 {
   m_FileIOs.push_back(new mitk::SurfaceVtkXmlIO());
   m_FileIOs.push_back(new mitk::SurfaceStlIO());
   m_FileIOs.push_back(new mitk::SurfaceVtkLegacyIO());
 
   m_FileIOs.push_back(new mitk::ImageVtkXmlIO());
   m_FileIOs.push_back(new mitk::ImageVtkLegacyIO());
 }
 
 void MitkCoreActivator::RegisterLegacyWriter()
 {
   std::list<itk::LightObject::Pointer> allobjects = itk::ObjectFactoryBase::CreateAllInstance("IOWriter");
 
   for (auto i = allobjects.begin(); i != allobjects.end(); ++i)
   {
     mitk::FileWriter::Pointer io = dynamic_cast<mitk::FileWriter *>(i->GetPointer());
     if (io)
     {
       std::string description = std::string("Legacy ") + io->GetNameOfClass() + " Writer";
       mitk::IFileWriter *writer = new mitk::LegacyFileWriterService(io, description);
       m_LegacyWriters.push_back(writer);
     }
     else
     {
       MITK_ERROR << "Error IOWriter override is not of type mitk::FileWriter: " << (*i)->GetNameOfClass() << std::endl;
     }
   }
 }
 
 US_EXPORT_MODULE_ACTIVATOR(MitkCoreActivator)
 
 // Call CppMicroservices initialization code at the end of the file.
 // This especially ensures that VTK object factories have already
 // been registered (VTK initialization code is injected by implicitly
 // include VTK header files at the top of this file).
 US_INITIALIZE_MODULE
diff --git a/Modules/Core/test/mitkPropertyRelationRuleBaseTest.cpp b/Modules/Core/test/mitkPropertyRelationRuleBaseTest.cpp
index 1be7a6b47e..a4cd0f314c 100644
--- a/Modules/Core/test/mitkPropertyRelationRuleBaseTest.cpp
+++ b/Modules/Core/test/mitkPropertyRelationRuleBaseTest.cpp
@@ -1,1101 +1,1146 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkPropertyRelationRuleBase.h"
 
 #include "mitkDataNode.h"
 #include "mitkPointSet.h"
 #include "mitkStringProperty.h"
 
 #include "mitkTestFixture.h"
 #include "mitkTestingMacros.h"
 
 #include <regex>
 
 /** This class is used to test PropertyRelationRuleBase and get access to internals where needed to test them as well.
  */
 namespace mitk
 {
   class TestRule : public mitk::PropertyRelationRuleBase
   {
   public:
     mitkClassMacro(TestRule, mitk::PropertyRelationRuleBase);
     itkFactorylessNewMacro(Self);
     itkCloneMacro(Self);
 
     using RuleIDType = PropertyRelationRuleBase::RuleIDType;
     using RelationUIDType = PropertyRelationRuleBase::RelationUIDType;
     using RelationUIDVectorType = PropertyRelationRuleBase::RelationUIDVectorType;
 
     RuleIDType GetRuleID() const override
     {
       if (m_AbstractMode)
       {
         return "TestRule";
       }
       else
       {
         return "TestRule_type1";
       }
     };
 
     std::string GetDisplayName() const override { return "TestDisplayName"; }
     std::string GetSourceRoleName() const override { return "source role"; }
     std::string GetDestinationRoleName() const override { return "destination role"; }
 
     bool m_AbstractMode;
 
     bool IsAbstract() const override { return m_AbstractMode; }
 
     using Superclass::GetRootKeyPath;
     using Superclass::Connect;
 
   protected:
     TestRule() : m_AbstractMode(false)
     {
     };
 
     ~TestRule() override = default;
 
     using InstanceIDType = PropertyRelationRuleBase::InstanceIDType;
     using InstanceIDVectorType = PropertyRelationRuleBase::InstanceIDVectorType;
 
     bool IsSupportedRuleID(const RuleIDType& ruleID) const override
     {
       if (m_AbstractMode)
       {
         return ruleID.find(this->GetRuleID()) == 0;
       }
       else
       {
         return Superclass::IsSupportedRuleID(ruleID);
       }
     };
 
     DataRelationUIDVectorType GetRelationUIDs_DataLayer(const IPropertyProvider* source,
       const IPropertyProvider* destination, const InstanceIDVectorType& instances_IDLayer) const override
     {
       DataRelationUIDVectorType result;
 
       mitk::BaseProperty::ConstPointer destProp;
 
       if (destination != nullptr)
       {
         destProp = destination->GetConstProperty("name");
       }
 
       if (destProp.IsNotNull())
       {
         auto destRegExStr =
           PropertyKeyPathToPropertyRegEx(Superclass::GetRootKeyPath().AddAnyElement().AddElement("dataHandle"));
         auto regEx = std::regex(destRegExStr);
         std::smatch instance_matches;
 
         auto keys = source->GetPropertyKeys();
 
         for (const auto &key : keys)
         {
           if (std::regex_search(key, instance_matches, regEx))
           {
             auto sourceProp = source->GetConstProperty(key);
             if (sourceProp->GetValueAsString() == destProp->GetValueAsString())
             {
               if (instance_matches.size()>1)
               {
                 auto finding = std::find(instances_IDLayer.begin(), instances_IDLayer.end(), instance_matches[1]);
                 if (finding == instances_IDLayer.end())
                 {
                   result.emplace_back(this->GetRelationUIDByInstanceID(source, instance_matches[1]), this->GetRuleIDByInstanceID(source, instance_matches[1]));
                 }
               }
             }
           }
         }
       }
 
       if (result.empty() && instances_IDLayer.empty())
       {
         auto refNameProp = source->GetConstProperty("referencedName");
         if (refNameProp.IsNotNull() && (destProp.IsNull() || destProp->GetValueAsString() == refNameProp->GetValueAsString()))
         {
           result.emplace_back(refNameProp->GetValueAsString(),"");
         }
       }
 
       return result;
     };
 
     void Connect_datalayer(IPropertyOwner *source,
                                    const IPropertyProvider *destination,
                                    const InstanceIDType &instanceID) const override
     {
       auto destProp = destination->GetConstProperty("name");
 
       source->SetProperty("referencedName", StringProperty::New(destProp->GetValueAsString()));
       source->SetProperty(
         PropertyKeyPathToPropertyName(Superclass::GetRootKeyPath().AddElement(instanceID).AddElement("dataHandle")),
         StringProperty::New(destProp->GetValueAsString()));
     };
 
     void Disconnect_datalayer(IPropertyOwner *source, const RelationUIDType & relationUID) const override
     {
       source->RemoveProperty("referencedName");
       try
       {
         auto instanceID = this->GetInstanceIDByRelationUID(source, relationUID);
         source->RemoveProperty(
             PropertyKeyPathToPropertyName(Superclass::GetRootKeyPath().AddElement(instanceID).AddElement("dataHandle")));
       }
       catch(...)
       { }
     };
   };
 } // namespace mitk
 
 class mitkPropertyRelationRuleBaseTestSuite : public mitk::TestFixture
 {
   CPPUNIT_TEST_SUITE(mitkPropertyRelationRuleBaseTestSuite);
 
   MITK_TEST(GetRootKeyPath);
   MITK_TEST(IsSourceCandidate);
   MITK_TEST(IsDestinationCandidate);
   MITK_TEST(IsSource);
   MITK_TEST(HasRelation);
   MITK_TEST(GetExistingRelations);
   MITK_TEST(GetRelationUIDs);
   MITK_TEST(GetSourceCandidateIndicator);
   MITK_TEST(GetDestinationCandidateIndicator);
   MITK_TEST(GetConnectedSourcesDetector);
   MITK_TEST(GetSourcesDetector);
   MITK_TEST(GetDestinationsDetector);
   MITK_TEST(GetDestinationDetector);
   MITK_TEST(Connect);
   MITK_TEST(Disconnect);
   MITK_TEST(Disconnect_partial_ID);
   MITK_TEST(Disconnect_partial_Data);
   MITK_TEST(Connect_abstract);
   MITK_TEST(Disconnect_abstract);
+  MITK_TEST(GetRIIPropertyKeyPath);
 
   CPPUNIT_TEST_SUITE_END();
 
 private:
   mitk::TestRule::Pointer rule;
   mitk::TestRule::Pointer abstractRule;
 
   mitk::DataNode::Pointer unRelated;
   mitk::PointSet::Pointer unRelated_1_data;
 
   mitk::DataNode::Pointer source_implicit_1;
   mitk::DataNode::Pointer source_data_1;
   mitk::DataNode::Pointer source_idOnly_1;
   mitk::DataNode::Pointer source_1;
 
   mitk::DataNode::Pointer source_multi;
 
   mitk::DataNode::Pointer source_otherRule;
 
   mitk::DataNode::Pointer source_otherTypeRule; //relevant for abstract rule checks. Abstract rule should see it concrete rule not.
 
   mitk::DataNode::Pointer dest_1;
   mitk::PointSet::Pointer dest_1_data;
   mitk::DataNode::Pointer dest_2;
   mitk::PointSet::Pointer dest_2_data;
 
   bool hasRelationProperties(mitk::IPropertyProvider *provider, std::string instance = "") const
   {
     auto keyPath = mitk::PropertyRelationRuleBase::GetRootKeyPath();
     if (!instance.empty())
     {
       keyPath.AddElement(instance);
     }
 
     auto prefix = mitk::PropertyKeyPathToPropertyName(keyPath);
     auto keys = provider->GetPropertyKeys();
 
     for (const auto &key : keys)
     {
       if (key.find(prefix) == 0)
       {
         return true;
       }
     }
 
     return false;
   }
 
 public:
   void setUp() override
   {
     rule = mitk::TestRule::New();
 
     abstractRule = mitk::TestRule::New();
     abstractRule->m_AbstractMode = true;
 
     unRelated = mitk::DataNode::New();
     unRelated->SetName("unRelated");
     unRelated_1_data = mitk::PointSet::New();
     unRelated->SetData(unRelated_1_data);
 
     dest_1 = mitk::DataNode::New();
     dest_1->SetName("dest_1");
     dest_1_data = mitk::PointSet::New();
     dest_1->SetData(dest_1_data);
 
     dest_2 = mitk::DataNode::New();
     dest_2->SetName("dest_2");
     dest_2_data = mitk::PointSet::New();
     dest_2->SetData(dest_2_data);
 
     source_implicit_1 = mitk::DataNode::New();
     source_implicit_1->AddProperty("referencedName", mitk::StringProperty::New(dest_1->GetName()));
 
     source_idOnly_1 = mitk::DataNode::New();
     std::string name = "MITK.Relations.1.relationUID";
     source_idOnly_1->AddProperty(name.c_str(), mitk::StringProperty::New("uid1"));
     name = "MITK.Relations.1.destinationUID";
     source_idOnly_1->AddProperty(name.c_str(), mitk::StringProperty::New(dest_1_data->GetUID()));
     name = "MITK.Relations.1.ruleID";
     source_idOnly_1->AddProperty(name.c_str(), mitk::StringProperty::New(rule->GetRuleID()));
 
     source_data_1 = mitk::DataNode::New();
     source_data_1->AddProperty("referencedName", mitk::StringProperty::New(dest_1->GetName()));
     name = "MITK.Relations.1.relationUID";
     source_data_1->AddProperty(name.c_str(), mitk::StringProperty::New("uid2"));
     name = "MITK.Relations.1.dataHandle";
     source_data_1->AddProperty(name.c_str(), mitk::StringProperty::New(dest_1->GetName()));
     name = "MITK.Relations.1.ruleID";
     source_data_1->AddProperty(name.c_str(), mitk::StringProperty::New(rule->GetRuleID()));
     name = "MITK.Relations.2.relationUID";
     source_data_1->AddProperty(name.c_str(), mitk::StringProperty::New("uid10"), nullptr, true);
     name = "MITK.Relations.2.destinationUID";
     source_data_1->AddProperty(name.c_str(), mitk::StringProperty::New(dest_1_data->GetUID()));
     name = "MITK.Relations.2.ruleID";
     source_data_1->AddProperty(name.c_str(), mitk::StringProperty::New("TestRule_othertype"));
 
     source_1 = mitk::DataNode::New();
     source_1->AddProperty("referencedName", mitk::StringProperty::New(dest_1->GetName()));
     name = "MITK.Relations.1.relationUID";
     source_1->AddProperty(name.c_str(), mitk::StringProperty::New("uid3"), nullptr, true);
     name = "MITK.Relations.1.destinationUID";
     source_1->AddProperty(name.c_str(), mitk::StringProperty::New(dest_1_data->GetUID()));
     name = "MITK.Relations.1.dataHandle";
     source_1->AddProperty(name.c_str(), mitk::StringProperty::New(dest_1->GetName()));
     name = "MITK.Relations.1.ruleID";
     source_1->AddProperty(name.c_str(), mitk::StringProperty::New(rule->GetRuleID()));
     name = "MITK.Relations.2.relationUID";
     source_1->AddProperty(name.c_str(), mitk::StringProperty::New("uid8"), nullptr, true);
     name = "MITK.Relations.2.destinationUID";
     source_1->AddProperty(name.c_str(), mitk::StringProperty::New(dest_2_data->GetUID()));
     name = "MITK.Relations.2.ruleID";
     source_1->AddProperty(name.c_str(), mitk::StringProperty::New("TestRule_othertype"));
 
     source_multi = mitk::DataNode::New();
     source_multi->AddProperty("referencedName", mitk::StringProperty::New(dest_1->GetName()));
     name = "MITK.Relations.1.relationUID";
     source_multi->AddProperty(name.c_str(), mitk::StringProperty::New("uid4"), nullptr, true);
     name = "MITK.Relations.1.destinationUID";
     source_multi->AddProperty(name.c_str(), mitk::StringProperty::New(dest_1_data->GetUID()));
     name = "MITK.Relations.1.ruleID";
     source_multi->AddProperty(name.c_str(), mitk::StringProperty::New(rule->GetRuleID()));
     name = "MITK.Relations.1.dataHandle";
     source_multi->AddProperty(name.c_str(), mitk::StringProperty::New(dest_1->GetName()));
     name = "MITK.Relations.4.relationUID";
     source_multi->AddProperty(name.c_str(), mitk::StringProperty::New("uid5"));
     name = "MITK.Relations.4.destinationUID";
     source_multi->AddProperty(name.c_str(), mitk::StringProperty::New(dest_2_data->GetUID()));
     name = "MITK.Relations.4.ruleID";
     source_multi->AddProperty(name.c_str(), mitk::StringProperty::New(rule->GetRuleID()));
     name = "MITK.Relations.2.relationUID";
     source_multi->AddProperty(name.c_str(), mitk::StringProperty::New("uid6"));
     name = "MITK.Relations.2.destinationUID";
     source_multi->AddProperty(name.c_str(), mitk::StringProperty::New("unknown"));
     name = "MITK.Relations.2.ruleID";
     source_multi->AddProperty(name.c_str(), mitk::StringProperty::New(rule->GetRuleID()));
 
     source_otherRule = mitk::DataNode::New();
     name = "MITK.Relations.1.relationUID";
     source_otherRule->AddProperty(name.c_str(), mitk::StringProperty::New("uid7"));
     name = "MITK.Relations.1.destinationUID";
     source_otherRule->AddProperty(name.c_str(), mitk::StringProperty::New(dest_1_data->GetUID()));
     name = "MITK.Relations.1.ruleID";
     source_otherRule->AddProperty(name.c_str(), mitk::StringProperty::New("otherRuleID"));
 
     source_otherTypeRule = mitk::DataNode::New();
     name = "MITK.Relations.1.relationUID";
     source_otherTypeRule->AddProperty(name.c_str(), mitk::StringProperty::New("uid9"));
     name = "MITK.Relations.1.destinationUID";
     source_otherTypeRule->AddProperty(name.c_str(), mitk::StringProperty::New(dest_1_data->GetUID()));
     name = "MITK.Relations.1.ruleID";
     source_otherTypeRule->AddProperty(name.c_str(), mitk::StringProperty::New("TestRule_othertype"));
   }
 
   void tearDown() override {}
 
   void GetRootKeyPath()
   {
     mitk::PropertyKeyPath ref;
     ref.AddElement("MITK").AddElement("Relations");
     CPPUNIT_ASSERT(mitk::PropertyRelationRuleBase::GetRootKeyPath() == ref);
   }
 
   void IsSourceCandidate()
   {
     CPPUNIT_ASSERT(rule->IsSourceCandidate(mitk::DataNode::New()));
     CPPUNIT_ASSERT(!rule->IsSourceCandidate(nullptr));
   }
 
   void IsDestinationCandidate()
   {
     CPPUNIT_ASSERT(rule->IsDestinationCandidate(mitk::DataNode::New()));
     CPPUNIT_ASSERT(!rule->IsDestinationCandidate(nullptr));
   }
 
   void IsSource()
   {
     CPPUNIT_ASSERT_THROW_MESSAGE(
       "Violated precondition (nullptr) does not throw.", rule->IsSource(nullptr), itk::ExceptionObject);
 
     CPPUNIT_ASSERT(!rule->IsSource(unRelated));
     CPPUNIT_ASSERT(rule->IsSource(source_implicit_1));
     CPPUNIT_ASSERT(rule->IsSource(source_data_1));
     CPPUNIT_ASSERT(rule->IsSource(source_idOnly_1));
     CPPUNIT_ASSERT(rule->IsSource(source_1));
     CPPUNIT_ASSERT(rule->IsSource(source_multi));
 
     CPPUNIT_ASSERT(!rule->IsSource(source_otherRule));
     CPPUNIT_ASSERT(!rule->IsSource(source_otherTypeRule));
 
     CPPUNIT_ASSERT(!abstractRule->IsSource(unRelated));
     CPPUNIT_ASSERT(abstractRule->IsSource(source_implicit_1));
     CPPUNIT_ASSERT(abstractRule->IsSource(source_data_1));
     CPPUNIT_ASSERT(abstractRule->IsSource(source_idOnly_1));
     CPPUNIT_ASSERT(abstractRule->IsSource(source_1));
     CPPUNIT_ASSERT(abstractRule->IsSource(source_multi));
 
     CPPUNIT_ASSERT(!abstractRule->IsSource(source_otherRule));
     CPPUNIT_ASSERT(abstractRule->IsSource(source_otherTypeRule));
   }
 
   void HasRelation()
   {
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (source is nullptr) does not throw.",
                                  rule->HasRelation(nullptr, dest_1),
                                  itk::ExceptionObject);
 
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (destination is nullptr) does not throw.",
                                  rule->HasRelation(source_1, nullptr),
                                  itk::ExceptionObject);
 
     CPPUNIT_ASSERT(!rule->HasRelation(source_1, unRelated));
     CPPUNIT_ASSERT(!rule->HasRelation(unRelated, dest_1));
     CPPUNIT_ASSERT(!rule->HasRelation(source_otherRule, dest_1));
     CPPUNIT_ASSERT(!rule->HasRelation(source_otherTypeRule, dest_1));
 
     CPPUNIT_ASSERT(rule->HasRelation(source_implicit_1, dest_1));
     CPPUNIT_ASSERT(rule->HasRelation(source_implicit_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Data));
     CPPUNIT_ASSERT(!rule->HasRelation(source_implicit_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::ID));
     CPPUNIT_ASSERT(!rule->HasRelation(source_implicit_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
 
     CPPUNIT_ASSERT(rule->HasRelation(source_data_1, dest_1));
     CPPUNIT_ASSERT(rule->HasRelation(source_data_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Data));
     CPPUNIT_ASSERT(!rule->HasRelation(source_data_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::ID));
     CPPUNIT_ASSERT(!rule->HasRelation(source_data_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
 
     CPPUNIT_ASSERT(rule->HasRelation(source_idOnly_1, dest_1));
     CPPUNIT_ASSERT(!rule->HasRelation(source_idOnly_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Data));
     CPPUNIT_ASSERT(rule->HasRelation(source_idOnly_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::ID));
     CPPUNIT_ASSERT(!rule->HasRelation(source_idOnly_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
 
     CPPUNIT_ASSERT(rule->HasRelation(source_1, dest_1));
     CPPUNIT_ASSERT(rule->HasRelation(source_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Data));
     CPPUNIT_ASSERT(rule->HasRelation(source_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::ID));
     CPPUNIT_ASSERT(rule->HasRelation(source_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
 
     CPPUNIT_ASSERT(!rule->HasRelation(source_1, dest_2));
     CPPUNIT_ASSERT(!rule->HasRelation(source_1, dest_2, mitk::PropertyRelationRuleBase::RelationType::Data));
     CPPUNIT_ASSERT(!rule->HasRelation(source_1, dest_2, mitk::PropertyRelationRuleBase::RelationType::ID));
     CPPUNIT_ASSERT(!rule->HasRelation(source_1, dest_2, mitk::PropertyRelationRuleBase::RelationType::Complete));
 
     CPPUNIT_ASSERT(rule->HasRelation(source_multi, dest_1));
     CPPUNIT_ASSERT(rule->HasRelation(source_multi, dest_1, mitk::PropertyRelationRuleBase::RelationType::Data));
     CPPUNIT_ASSERT(rule->HasRelation(source_multi, dest_1, mitk::PropertyRelationRuleBase::RelationType::ID));
     CPPUNIT_ASSERT(rule->HasRelation(source_multi, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
 
     CPPUNIT_ASSERT(rule->HasRelation(source_multi, dest_2));
     CPPUNIT_ASSERT(!rule->HasRelation(source_multi, dest_2, mitk::PropertyRelationRuleBase::RelationType::Data));
     CPPUNIT_ASSERT(rule->HasRelation(source_multi, dest_2, mitk::PropertyRelationRuleBase::RelationType::ID));
     CPPUNIT_ASSERT(!rule->HasRelation(source_multi, dest_2, mitk::PropertyRelationRuleBase::RelationType::Complete));
 
 
     CPPUNIT_ASSERT(!abstractRule->HasRelation(source_1, unRelated));
     CPPUNIT_ASSERT(!abstractRule->HasRelation(unRelated, dest_1));
     CPPUNIT_ASSERT(!abstractRule->HasRelation(source_otherRule, dest_1));
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_otherTypeRule, dest_1));
     CPPUNIT_ASSERT(!abstractRule->HasRelation(source_otherTypeRule, dest_1, mitk::PropertyRelationRuleBase::RelationType::Data));
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_otherTypeRule, dest_1, mitk::PropertyRelationRuleBase::RelationType::ID));
     CPPUNIT_ASSERT(!abstractRule->HasRelation(source_otherTypeRule, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
 
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_implicit_1, dest_1));
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_implicit_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Data));
     CPPUNIT_ASSERT(!abstractRule->HasRelation(source_implicit_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::ID));
     CPPUNIT_ASSERT(!abstractRule->HasRelation(source_implicit_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
 
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_data_1, dest_1));
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_data_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Data));
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_data_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::ID));
     CPPUNIT_ASSERT(!abstractRule->HasRelation(source_data_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
 
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_idOnly_1, dest_1));
     CPPUNIT_ASSERT(!abstractRule->HasRelation(source_idOnly_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Data));
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_idOnly_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::ID));
     CPPUNIT_ASSERT(!abstractRule->HasRelation(source_idOnly_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
 
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_1, dest_1));
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Data));
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::ID));
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
 
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_1, dest_2));
     CPPUNIT_ASSERT(!abstractRule->HasRelation(source_1, dest_2, mitk::PropertyRelationRuleBase::RelationType::Data));
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_1, dest_2, mitk::PropertyRelationRuleBase::RelationType::ID));
     CPPUNIT_ASSERT(!abstractRule->HasRelation(source_1, dest_2, mitk::PropertyRelationRuleBase::RelationType::Complete));
 
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_multi, dest_1));
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_multi, dest_1, mitk::PropertyRelationRuleBase::RelationType::Data));
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_multi, dest_1, mitk::PropertyRelationRuleBase::RelationType::ID));
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_multi, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
 
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_multi, dest_2));
     CPPUNIT_ASSERT(!abstractRule->HasRelation(source_multi, dest_2, mitk::PropertyRelationRuleBase::RelationType::Data));
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_multi, dest_2, mitk::PropertyRelationRuleBase::RelationType::ID));
     CPPUNIT_ASSERT(!abstractRule->HasRelation(source_multi, dest_2, mitk::PropertyRelationRuleBase::RelationType::Complete));
   }
 
   void GetExistingRelations()
   {
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (source is nullptr) does not throw.",
                                  rule->GetExistingRelations(nullptr),
                                  itk::ExceptionObject);
 
     CPPUNIT_ASSERT(rule->GetExistingRelations(unRelated).empty());
     CPPUNIT_ASSERT(rule->GetExistingRelations(source_otherRule).empty());
     CPPUNIT_ASSERT(rule->GetExistingRelations(source_otherTypeRule).empty());
 
     auto uids = rule->GetExistingRelations(source_implicit_1);
     CPPUNIT_ASSERT(uids.size() == 1);
     CPPUNIT_ASSERT(uids.front() == dest_1->GetName());
 
     uids = rule->GetExistingRelations(source_idOnly_1);
     CPPUNIT_ASSERT(uids.size() == 1);
     CPPUNIT_ASSERT(uids.front() == "uid1");
 
     uids = rule->GetExistingRelations(source_data_1);
     CPPUNIT_ASSERT(uids.size() == 1);
     CPPUNIT_ASSERT(uids.front() == "uid2");
 
     uids = rule->GetExistingRelations(source_1);
     CPPUNIT_ASSERT(uids.size() == 1);
     CPPUNIT_ASSERT(uids.front() == "uid3");
 
     uids = rule->GetExistingRelations(source_multi);
     CPPUNIT_ASSERT(uids.size() == 3);
     CPPUNIT_ASSERT(std::find(uids.begin(), uids.end(), "uid4") != uids.end());
     CPPUNIT_ASSERT(std::find(uids.begin(), uids.end(), "uid5") != uids.end());
     CPPUNIT_ASSERT(std::find(uids.begin(), uids.end(), "uid6") != uids.end());
 
 
     CPPUNIT_ASSERT(abstractRule->GetExistingRelations(unRelated).empty());
     CPPUNIT_ASSERT(abstractRule->GetExistingRelations(source_otherRule).empty());
 
     uids = abstractRule->GetExistingRelations(source_implicit_1);
     CPPUNIT_ASSERT(uids.size() == 1);
     CPPUNIT_ASSERT(uids.front() == dest_1->GetName());
 
     uids = abstractRule->GetExistingRelations(source_idOnly_1);
     CPPUNIT_ASSERT(uids.size() == 1);
     CPPUNIT_ASSERT(uids.front() == "uid1");
 
     uids = abstractRule->GetExistingRelations(source_data_1);
     CPPUNIT_ASSERT(uids.size() == 2);
     CPPUNIT_ASSERT(std::find(uids.begin(), uids.end(), "uid2") != uids.end());
     CPPUNIT_ASSERT(std::find(uids.begin(), uids.end(), "uid10") != uids.end());
 
     uids = abstractRule->GetExistingRelations(source_1);
     CPPUNIT_ASSERT(uids.size() == 2);
     CPPUNIT_ASSERT(std::find(uids.begin(), uids.end(), "uid3") != uids.end());
     CPPUNIT_ASSERT(std::find(uids.begin(), uids.end(), "uid8") != uids.end());
 
     uids = abstractRule->GetExistingRelations(source_multi);
     CPPUNIT_ASSERT(uids.size() == 3);
     CPPUNIT_ASSERT(std::find(uids.begin(), uids.end(), "uid4") != uids.end());
     CPPUNIT_ASSERT(std::find(uids.begin(), uids.end(), "uid5") != uids.end());
     CPPUNIT_ASSERT(std::find(uids.begin(), uids.end(), "uid6") != uids.end());
 
     uids = abstractRule->GetExistingRelations(source_otherTypeRule);
     CPPUNIT_ASSERT(uids.size() == 1);
     CPPUNIT_ASSERT(uids.front() == "uid9");
 
   }
 
   void GetRelationUIDs()
   {
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (source is nullptr) does not throw.",
                                  rule->GetRelationUIDs(nullptr, dest_1),
                                  itk::ExceptionObject);
 
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (destination is nullptr) does not throw.",
                                  rule->GetRelationUIDs(source_1, nullptr),
                                  itk::ExceptionObject);
 
     CPPUNIT_ASSERT(rule->GetRelationUIDs(source_1, unRelated).empty());
     CPPUNIT_ASSERT(rule->GetRelationUIDs(source_1, dest_2).empty());
     CPPUNIT_ASSERT(rule->GetRelationUIDs(unRelated, dest_1).empty());
     CPPUNIT_ASSERT(rule->GetRelationUIDs(source_otherRule, dest_1).empty());
     CPPUNIT_ASSERT(rule->GetRelationUIDs(source_otherTypeRule, dest_1).empty());
 
     CPPUNIT_ASSERT(rule->GetRelationUIDs(source_idOnly_1, dest_1).front() == "uid1");
     CPPUNIT_ASSERT(rule->GetRelationUIDs(source_data_1, dest_1).front() == "uid2");
     auto uids = rule->GetRelationUIDs(source_1, dest_1);
     CPPUNIT_ASSERT(uids.size() == 1);
     CPPUNIT_ASSERT(uids.front() == "uid3");
     CPPUNIT_ASSERT(rule->GetRelationUIDs(source_multi, dest_1).front() == "uid4");
     CPPUNIT_ASSERT(rule->GetRelationUIDs(source_multi, dest_2).front() == "uid5");
 
     CPPUNIT_ASSERT(abstractRule->GetRelationUIDs(source_1, unRelated).empty());
     CPPUNIT_ASSERT(abstractRule->GetRelationUIDs(unRelated, dest_1).empty());
     CPPUNIT_ASSERT(abstractRule->GetRelationUIDs(source_otherRule, dest_1).empty());
     CPPUNIT_ASSERT(abstractRule->GetRelationUIDs(source_otherTypeRule, dest_1).front() == "uid9");
 
     CPPUNIT_ASSERT(abstractRule->GetRelationUIDs(source_idOnly_1, dest_1).front() == "uid1");
     uids = abstractRule->GetRelationUIDs(source_data_1, dest_1);
     CPPUNIT_ASSERT(uids.size() == 2);
     CPPUNIT_ASSERT(std::find(uids.begin(), uids.end(), "uid2") != uids.end());
     CPPUNIT_ASSERT(std::find(uids.begin(), uids.end(), "uid10") != uids.end());
     uids = abstractRule->GetRelationUIDs(source_1, dest_1);
     CPPUNIT_ASSERT(uids.size() == 1);
     CPPUNIT_ASSERT(std::find(uids.begin(), uids.end(), "uid3") != uids.end());
     uids = abstractRule->GetRelationUIDs(source_1, dest_2);
     CPPUNIT_ASSERT(uids.size() == 1);
     CPPUNIT_ASSERT(std::find(uids.begin(), uids.end(), "uid8") != uids.end());
     CPPUNIT_ASSERT(abstractRule->GetRelationUIDs(source_1, dest_1).front() == "uid3");
     CPPUNIT_ASSERT(abstractRule->GetRelationUIDs(source_multi, dest_1).front() == "uid4");
     CPPUNIT_ASSERT(abstractRule->GetRelationUIDs(source_multi, dest_2).front() == "uid5");
 
   }
 
   void GetSourceCandidateIndicator()
   {
     auto predicate = rule->GetSourceCandidateIndicator();
 
     CPPUNIT_ASSERT(predicate->CheckNode(mitk::DataNode::New()));
     CPPUNIT_ASSERT(!predicate->CheckNode(nullptr));
   }
 
   void GetDestinationCandidateIndicator()
   {
     auto predicate = rule->GetDestinationCandidateIndicator();
 
     CPPUNIT_ASSERT(predicate->CheckNode(mitk::DataNode::New()));
     CPPUNIT_ASSERT(!predicate->CheckNode(nullptr));
   }
 
   void GetConnectedSourcesDetector()
   {
     auto predicate = rule->GetConnectedSourcesDetector();
 
     CPPUNIT_ASSERT(!predicate->CheckNode(nullptr));
     CPPUNIT_ASSERT(!predicate->CheckNode(unRelated));
     CPPUNIT_ASSERT(predicate->CheckNode(source_implicit_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_data_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_idOnly_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_multi));
 
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherRule));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherTypeRule));
 
 
     auto predicate2 = abstractRule->GetConnectedSourcesDetector();
 
     CPPUNIT_ASSERT(!predicate2->CheckNode(nullptr));
     CPPUNIT_ASSERT(!predicate2->CheckNode(unRelated));
     CPPUNIT_ASSERT(predicate2->CheckNode(source_implicit_1));
     CPPUNIT_ASSERT(predicate2->CheckNode(source_data_1));
     CPPUNIT_ASSERT(predicate2->CheckNode(source_idOnly_1));
     CPPUNIT_ASSERT(predicate2->CheckNode(source_1));
     CPPUNIT_ASSERT(predicate2->CheckNode(source_multi));
 
     CPPUNIT_ASSERT(!predicate2->CheckNode(source_otherRule));
     CPPUNIT_ASSERT(predicate2->CheckNode(source_otherTypeRule));
   }
 
   void GetSourcesDetector()
   {
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (destination is nullptr) does not throw.",
                                  rule->GetSourcesDetector(nullptr),
                                  itk::ExceptionObject);
 
     auto predicate = rule->GetSourcesDetector(dest_1);
 
     CPPUNIT_ASSERT(!predicate->CheckNode(unRelated));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherRule));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherTypeRule));
 
     CPPUNIT_ASSERT(predicate->CheckNode(source_implicit_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_data_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_idOnly_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_multi));
 
     predicate = rule->GetSourcesDetector(dest_1, mitk::PropertyRelationRuleBase::RelationType::Data);
 
     CPPUNIT_ASSERT(!predicate->CheckNode(unRelated));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherRule));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherTypeRule));
 
     CPPUNIT_ASSERT(predicate->CheckNode(source_implicit_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_data_1));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_idOnly_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_multi));
 
     predicate = rule->GetSourcesDetector(dest_1, mitk::PropertyRelationRuleBase::RelationType::ID);
 
     CPPUNIT_ASSERT(!predicate->CheckNode(unRelated));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherRule));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherTypeRule));
 
     CPPUNIT_ASSERT(!predicate->CheckNode(source_implicit_1));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_data_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_idOnly_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_multi));
 
     predicate = rule->GetSourcesDetector(dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete);
 
     CPPUNIT_ASSERT(!predicate->CheckNode(unRelated));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherRule));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherTypeRule));
 
     CPPUNIT_ASSERT(!predicate->CheckNode(source_implicit_1));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_data_1));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_idOnly_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_multi));
 
     predicate = rule->GetSourcesDetector(dest_2);
 
     CPPUNIT_ASSERT(!predicate->CheckNode(unRelated));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherRule));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherTypeRule));
 
     CPPUNIT_ASSERT(!predicate->CheckNode(source_implicit_1));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_data_1));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_idOnly_1));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_multi));
 
     predicate = abstractRule->GetSourcesDetector(dest_1, mitk::PropertyRelationRuleBase::RelationType::ID);
 
     CPPUNIT_ASSERT(!predicate->CheckNode(unRelated));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherRule));
     CPPUNIT_ASSERT(predicate->CheckNode(source_otherTypeRule));
 
     CPPUNIT_ASSERT(!predicate->CheckNode(source_implicit_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_data_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_idOnly_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_multi));
 
     predicate = abstractRule->GetSourcesDetector(dest_1, mitk::PropertyRelationRuleBase::RelationType::Data);
 
     CPPUNIT_ASSERT(!predicate->CheckNode(unRelated));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherRule));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherTypeRule));
 
     CPPUNIT_ASSERT(predicate->CheckNode(source_implicit_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_data_1));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_idOnly_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_multi));
 
     predicate = abstractRule->GetSourcesDetector(dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete);
 
     CPPUNIT_ASSERT(!predicate->CheckNode(unRelated));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherRule));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherTypeRule));
 
     CPPUNIT_ASSERT(!predicate->CheckNode(source_implicit_1));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_data_1));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_idOnly_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_multi));
 
     predicate = abstractRule->GetSourcesDetector(dest_1);
 
     CPPUNIT_ASSERT(!predicate->CheckNode(unRelated));
     CPPUNIT_ASSERT(!predicate->CheckNode(source_otherRule));
     CPPUNIT_ASSERT(predicate->CheckNode(source_otherTypeRule));
 
     CPPUNIT_ASSERT(predicate->CheckNode(source_implicit_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_data_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_idOnly_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_1));
     CPPUNIT_ASSERT(predicate->CheckNode(source_multi));
   }
 
   void GetDestinationsDetector()
   {
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (source is nullptr) does not throw.",
                                  rule->GetDestinationsDetector(nullptr),
                                  itk::ExceptionObject);
 
     auto predicate = rule->GetDestinationsDetector(source_otherRule);
     CPPUNIT_ASSERT(!predicate->CheckNode(dest_1));
 
     predicate = rule->GetDestinationsDetector(source_otherTypeRule);
     CPPUNIT_ASSERT(!predicate->CheckNode(dest_1));
 
     predicate = rule->GetDestinationsDetector(source_implicit_1);
     CPPUNIT_ASSERT(predicate->CheckNode(dest_1));
     predicate =
       rule->GetDestinationsDetector(source_implicit_1, mitk::PropertyRelationRuleBase::RelationType::Data);
     CPPUNIT_ASSERT(predicate->CheckNode(dest_1));
     predicate =
       rule->GetDestinationsDetector(source_implicit_1, mitk::PropertyRelationRuleBase::RelationType::ID);
     CPPUNIT_ASSERT(!predicate->CheckNode(dest_1));
     predicate =
       rule->GetDestinationsDetector(source_implicit_1, mitk::PropertyRelationRuleBase::RelationType::Complete);
     CPPUNIT_ASSERT(!predicate->CheckNode(dest_1));
 
     predicate = rule->GetDestinationsDetector(source_data_1);
     CPPUNIT_ASSERT(predicate->CheckNode(dest_1));
     predicate =
       rule->GetDestinationsDetector(source_data_1, mitk::PropertyRelationRuleBase::RelationType::Data);
     CPPUNIT_ASSERT(predicate->CheckNode(dest_1));
     predicate =
       rule->GetDestinationsDetector(source_data_1, mitk::PropertyRelationRuleBase::RelationType::ID);
     CPPUNIT_ASSERT(!predicate->CheckNode(dest_1));
     predicate =
       rule->GetDestinationsDetector(source_data_1, mitk::PropertyRelationRuleBase::RelationType::Complete);
     CPPUNIT_ASSERT(!predicate->CheckNode(dest_1));
 
     predicate = rule->GetDestinationsDetector(source_idOnly_1);
     CPPUNIT_ASSERT(predicate->CheckNode(dest_1));
     predicate =
       rule->GetDestinationsDetector(source_idOnly_1, mitk::PropertyRelationRuleBase::RelationType::Data);
     CPPUNIT_ASSERT(!predicate->CheckNode(dest_1));
     predicate =
       rule->GetDestinationsDetector(source_idOnly_1, mitk::PropertyRelationRuleBase::RelationType::ID);
     CPPUNIT_ASSERT(predicate->CheckNode(dest_1));
     predicate =
       rule->GetDestinationsDetector(source_idOnly_1, mitk::PropertyRelationRuleBase::RelationType::Complete);
     CPPUNIT_ASSERT(!predicate->CheckNode(dest_1));
 
     predicate = rule->GetDestinationsDetector(source_1);
     CPPUNIT_ASSERT(predicate->CheckNode(dest_1));
     CPPUNIT_ASSERT(!predicate->CheckNode(unRelated));
     CPPUNIT_ASSERT(!predicate->CheckNode(dest_2));
     predicate =
       rule->GetDestinationsDetector(source_1, mitk::PropertyRelationRuleBase::RelationType::Data);
     CPPUNIT_ASSERT(predicate->CheckNode(dest_1));
     CPPUNIT_ASSERT(!predicate->CheckNode(unRelated));
     CPPUNIT_ASSERT(!predicate->CheckNode(dest_2));
     predicate =
       rule->GetDestinationsDetector(source_1, mitk::PropertyRelationRuleBase::RelationType::ID);
     CPPUNIT_ASSERT(predicate->CheckNode(dest_1));
     CPPUNIT_ASSERT(!predicate->CheckNode(unRelated));
     CPPUNIT_ASSERT(!predicate->CheckNode(dest_2));
     predicate =
       rule->GetDestinationsDetector(source_1, mitk::PropertyRelationRuleBase::RelationType::Complete);
     CPPUNIT_ASSERT(predicate->CheckNode(dest_1));
     CPPUNIT_ASSERT(!predicate->CheckNode(unRelated));
     CPPUNIT_ASSERT(!predicate->CheckNode(dest_2));
 
     predicate = rule->GetDestinationsDetector(source_multi);
     CPPUNIT_ASSERT(predicate->CheckNode(dest_1));
     CPPUNIT_ASSERT(predicate->CheckNode(dest_2));
     predicate =
       rule->GetDestinationsDetector(source_multi, mitk::PropertyRelationRuleBase::RelationType::Data);
     CPPUNIT_ASSERT(predicate->CheckNode(dest_1));
     CPPUNIT_ASSERT(!predicate->CheckNode(dest_2));
     predicate =
       rule->GetDestinationsDetector(source_multi, mitk::PropertyRelationRuleBase::RelationType::ID);
     CPPUNIT_ASSERT(predicate->CheckNode(dest_1));
     CPPUNIT_ASSERT(predicate->CheckNode(dest_2));
     predicate =
       rule->GetDestinationsDetector(source_multi, mitk::PropertyRelationRuleBase::RelationType::Complete);
     CPPUNIT_ASSERT(predicate->CheckNode(dest_1));
     CPPUNIT_ASSERT(!predicate->CheckNode(dest_2));
 
     predicate = abstractRule->GetDestinationsDetector(source_otherTypeRule);
     CPPUNIT_ASSERT(predicate->CheckNode(dest_1));
     predicate = abstractRule->GetDestinationsDetector(source_otherTypeRule);
     CPPUNIT_ASSERT(predicate->CheckNode(dest_1));
 
   }
 
   void GetDestinationDetector()
   {
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (source is nullptr) does not throw.",
                                  rule->GetDestinationDetector(nullptr, "uid1"),
                                  itk::ExceptionObject);
 
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (relation uid is invalid) does not throw.",
                                  rule->GetDestinationDetector(source_1, "invalid uid"),
                                  itk::ExceptionObject);
 
     auto predicate = rule->GetDestinationDetector(source_1, "uid3");
     CPPUNIT_ASSERT(!predicate->CheckNode(unRelated));
     CPPUNIT_ASSERT(predicate->CheckNode(dest_1));
     CPPUNIT_ASSERT(!predicate->CheckNode(dest_2));
 
     predicate = rule->GetDestinationDetector(source_multi, "uid5");
     CPPUNIT_ASSERT(!predicate->CheckNode(unRelated));
     CPPUNIT_ASSERT(!predicate->CheckNode(dest_1));
     CPPUNIT_ASSERT(predicate->CheckNode(dest_2));
   }
 
   void Connect()
   {
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (source is nullptr) does not throw.",
                                  rule->Connect(nullptr, dest_1),
                                  itk::ExceptionObject);
 
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (destination is nullptr) does not throw.",
                                  rule->Connect(source_1, nullptr),
                                  itk::ExceptionObject);
 
     // check upgrade of an implicit connection
     CPPUNIT_ASSERT(!rule->HasRelation(source_implicit_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
     rule->Connect(source_implicit_1, dest_1);
     CPPUNIT_ASSERT(rule->HasRelation(source_implicit_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
 
     // check upgrade of an data connection
     CPPUNIT_ASSERT(!rule->HasRelation(source_data_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
     rule->Connect(source_data_1, dest_1);
     CPPUNIT_ASSERT(rule->HasRelation(source_data_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
     std::string name = "MITK.Relations.1.destinationUID";
     auto prop = source_data_1->GetProperty(name.c_str());
     CPPUNIT_ASSERT_MESSAGE(
       "Destination uid was not stored with the correct key. Already existing session should be used.", prop);
     CPPUNIT_ASSERT_MESSAGE("Incorrect destination uid was  stored.", prop->GetValueAsString() == dest_1_data->GetUID());
 
     // check actualization of an id only connection
     CPPUNIT_ASSERT(!rule->HasRelation(source_idOnly_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
     rule->Connect(source_idOnly_1, dest_1);
     CPPUNIT_ASSERT(rule->HasRelation(source_idOnly_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
     CPPUNIT_ASSERT_MESSAGE("Additional relation was defined instead of updating exting one.",
                            rule->GetExistingRelations(source_1).size() == 1);
     name = "MITK.Relations.1.dataHandle";
     prop = source_idOnly_1->GetProperty(name.c_str());
     CPPUNIT_ASSERT_MESSAGE(
       "Data layer information was not stored with the correct key. Already existing session should be used.", prop);
     CPPUNIT_ASSERT_MESSAGE("Incorrect data layer information not stored.",
                            prop->GetValueAsString() == dest_1->GetName());
     prop = source_idOnly_1->GetProperty("referencedName");
     CPPUNIT_ASSERT_MESSAGE(
       "Data layer information was not stored with the correct key. Already existing session should be used.", prop);
     CPPUNIT_ASSERT_MESSAGE("Incorrect data layer information was stored.",
                            prop->GetValueAsString() == dest_1->GetName());
 
     // check actualization of an existing connection
     rule->Connect(source_1, dest_1);
     CPPUNIT_ASSERT(rule->HasRelation(source_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
     CPPUNIT_ASSERT_MESSAGE("Additional relation was defined instead of updating exting one.",
                            rule->GetExistingRelations(source_1).size() == 1);
 
     // check new connection
     auto newConnectUID = rule->Connect(source_multi, unRelated);
     CPPUNIT_ASSERT(rule->HasRelation(source_multi, unRelated, mitk::PropertyRelationRuleBase::RelationType::Complete));
     name = "MITK.Relations.5.dataHandle";
     prop = source_multi->GetProperty(name.c_str());
     CPPUNIT_ASSERT_MESSAGE(
       "Data layer information was not stored with the correct key. Already existing session should be used.", prop);
     CPPUNIT_ASSERT_MESSAGE("Incorrect data layer information was stored.",
                            prop->GetValueAsString() == unRelated->GetName());
     prop = source_multi->GetProperty("referencedName");
     CPPUNIT_ASSERT_MESSAGE(
       "Data layer information was not stored with the correct key. Already existing session should be used.", prop);
     CPPUNIT_ASSERT_MESSAGE("Incorrect data layer information was stored.",
                            prop->GetValueAsString() == unRelated->GetName());
     name = "MITK.Relations.5.destinationUID";
     prop = source_multi->GetProperty(name.c_str());
     CPPUNIT_ASSERT_MESSAGE(
       "Destination uid was not stored with the correct key. Already existing session should be used.", prop);
     CPPUNIT_ASSERT_MESSAGE("Incorrect destination uid was stored.", prop->GetValueAsString() == unRelated_1_data->GetUID());
 
     auto storedRelationUIDs = rule->GetRelationUIDs(source_multi, unRelated);
     CPPUNIT_ASSERT_MESSAGE(
       "Relation uid was not stored for given source and destination.", storedRelationUIDs.size() == 1);
     CPPUNIT_ASSERT_MESSAGE("Incorrect Relation uid was stored.", storedRelationUIDs[0] == newConnectUID);
   }
 
   void Disconnect()
   {
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (source is nullptr) does not throw.",
                                  rule->Disconnect(nullptr, dest_1),
                                  itk::ExceptionObject);
 
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (destination is nullptr) does not throw.",
                                  rule->Disconnect(source_1, nullptr),
                                  itk::ExceptionObject);
 
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (destination is nullptr) does not throw.",
                                  rule->Disconnect(nullptr, "uid"),
                                  itk::ExceptionObject);
 
     CPPUNIT_ASSERT(!rule->HasRelation(source_1, unRelated, mitk::PropertyRelationRuleBase::RelationType::None));
     rule->Disconnect(source_1, unRelated);
     CPPUNIT_ASSERT(!rule->HasRelation(source_1, unRelated, mitk::PropertyRelationRuleBase::RelationType::None));
     CPPUNIT_ASSERT_MESSAGE("Data property was illegaly removed.", source_1->GetProperty("referencedName"));
 
     rule->Disconnect(source_1, dest_2);
     CPPUNIT_ASSERT(!rule->HasRelation(source_1, dest_2, mitk::PropertyRelationRuleBase::RelationType::None));
     CPPUNIT_ASSERT(this->hasRelationProperties(source_1));
 
     CPPUNIT_ASSERT(rule->HasRelation(source_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
     rule->Disconnect(source_1, dest_1);
     CPPUNIT_ASSERT(!rule->HasRelation(source_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::None));
     CPPUNIT_ASSERT(!this->hasRelationProperties(source_1, "1"));
     CPPUNIT_ASSERT_MESSAGE("Data of other rule type was removed.",this->hasRelationProperties(source_1, "2"));
 
     CPPUNIT_ASSERT(rule->HasRelation(source_multi, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
     rule->Disconnect(source_multi, dest_1);
     CPPUNIT_ASSERT(!rule->HasRelation(source_multi, dest_1, mitk::PropertyRelationRuleBase::RelationType::None));
     CPPUNIT_ASSERT(!this->hasRelationProperties(source_multi, "1"));
     CPPUNIT_ASSERT(this->hasRelationProperties(source_multi, "2"));
     CPPUNIT_ASSERT(this->hasRelationProperties(source_multi, "4"));
 
     rule->Disconnect(source_multi, "uid6");
     CPPUNIT_ASSERT(!this->hasRelationProperties(source_multi, "1"));
     CPPUNIT_ASSERT(!this->hasRelationProperties(source_multi, "2"));
     CPPUNIT_ASSERT(this->hasRelationProperties(source_multi, "4"));
 
     rule->Disconnect(source_multi, "unkownRelationUID");
     CPPUNIT_ASSERT(!this->hasRelationProperties(source_multi, "1"));
     CPPUNIT_ASSERT(!this->hasRelationProperties(source_multi, "2"));
     CPPUNIT_ASSERT(this->hasRelationProperties(source_multi, "4"));
 
     rule->Disconnect(source_otherTypeRule, dest_1);
     CPPUNIT_ASSERT_MESSAGE("Data of other rule type was removed.", this->hasRelationProperties(source_otherTypeRule, "1"));
   }
 
   void Disconnect_partial_ID()
   {
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (source is nullptr) does not throw.",
       rule->Disconnect(nullptr, dest_1, mitk::PropertyRelationRuleBase::RelationType::ID),
       itk::ExceptionObject);
 
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (destination is nullptr) does not throw.",
       rule->Disconnect(source_1, nullptr, mitk::PropertyRelationRuleBase::RelationType::ID),
       itk::ExceptionObject);
 
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (destination is nullptr) does not throw.",
       rule->Disconnect(nullptr, "uid", mitk::PropertyRelationRuleBase::RelationType::ID),
       itk::ExceptionObject);
 
     CPPUNIT_ASSERT(!rule->HasRelation(source_1, unRelated, mitk::PropertyRelationRuleBase::RelationType::None));
     rule->Disconnect(source_1, unRelated, mitk::PropertyRelationRuleBase::RelationType::ID);
     CPPUNIT_ASSERT(!rule->HasRelation(source_1, unRelated, mitk::PropertyRelationRuleBase::RelationType::None));
     CPPUNIT_ASSERT_MESSAGE("Data property was illegaly removed.", source_1->GetProperty("referencedName"));
 
     rule->Disconnect(source_idOnly_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::ID);
     CPPUNIT_ASSERT(!rule->HasRelation(source_idOnly_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::None));
 
     rule->Disconnect(source_data_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::ID);
     CPPUNIT_ASSERT(rule->HasRelation(source_data_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Data));
 
     CPPUNIT_ASSERT(rule->HasRelation(source_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
     rule->Disconnect(source_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::ID);
     CPPUNIT_ASSERT(rule->HasRelation(source_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Data));
     CPPUNIT_ASSERT(!this->hasRelationProperties(source_1, "1"));
     CPPUNIT_ASSERT_MESSAGE("Data of other rule type was removed.", this->hasRelationProperties(source_1, "2"));
   }
 
   void Disconnect_partial_Data()
   {
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (source is nullptr) does not throw.",
       rule->Disconnect(nullptr, dest_1, mitk::PropertyRelationRuleBase::RelationType::Data),
       itk::ExceptionObject);
 
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (destination is nullptr) does not throw.",
       rule->Disconnect(source_1, nullptr, mitk::PropertyRelationRuleBase::RelationType::Data),
       itk::ExceptionObject);
 
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (destination is nullptr) does not throw.",
       rule->Disconnect(nullptr, "uid", mitk::PropertyRelationRuleBase::RelationType::Data),
       itk::ExceptionObject);
 
     CPPUNIT_ASSERT(!rule->HasRelation(source_1, unRelated, mitk::PropertyRelationRuleBase::RelationType::None));
     rule->Disconnect(source_1, unRelated, mitk::PropertyRelationRuleBase::RelationType::Data);
     CPPUNIT_ASSERT(!rule->HasRelation(source_1, unRelated, mitk::PropertyRelationRuleBase::RelationType::None));
     CPPUNIT_ASSERT_MESSAGE("Data property was illegaly removed.", source_1->GetProperty("referencedName"));
 
     rule->Disconnect(source_idOnly_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Data);
     CPPUNIT_ASSERT(rule->HasRelation(source_idOnly_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::ID));
 
     rule->Disconnect(source_data_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Data);
     CPPUNIT_ASSERT(!rule->HasRelation(source_data_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::None));
 
     CPPUNIT_ASSERT(rule->HasRelation(source_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
     rule->Disconnect(source_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Data);
     CPPUNIT_ASSERT(rule->HasRelation(source_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::ID));
   }
 
   void Connect_abstract()
   {
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (abstract does not connect) does not throw.",
       abstractRule->Connect(nullptr, dest_1),
       itk::ExceptionObject);
 
     CPPUNIT_ASSERT_THROW_MESSAGE("Violated precondition (abstract does not connect) does not throw.",
       abstractRule->Connect(source_1, nullptr),
       itk::ExceptionObject);
   }
 
   void Disconnect_abstract()
   {
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_1, dest_2, mitk::PropertyRelationRuleBase::RelationType::ID));
     abstractRule->Disconnect(source_1, dest_2);
     CPPUNIT_ASSERT(!abstractRule->HasRelation(source_1, dest_2, mitk::PropertyRelationRuleBase::RelationType::None));
     CPPUNIT_ASSERT(!this->hasRelationProperties(source_1, "2"));
 
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
     abstractRule->Disconnect(source_1, dest_1);
     CPPUNIT_ASSERT(!abstractRule->HasRelation(source_1, dest_1, mitk::PropertyRelationRuleBase::RelationType::None));
     CPPUNIT_ASSERT(!this->hasRelationProperties(source_1, "1"));
 
     CPPUNIT_ASSERT(abstractRule->HasRelation(source_multi, dest_1, mitk::PropertyRelationRuleBase::RelationType::Complete));
     abstractRule->Disconnect(source_multi, dest_1);
     CPPUNIT_ASSERT(!abstractRule->HasRelation(source_multi, dest_1, mitk::PropertyRelationRuleBase::RelationType::None));
     CPPUNIT_ASSERT(!this->hasRelationProperties(source_multi, "1"));
     CPPUNIT_ASSERT(this->hasRelationProperties(source_multi, "2"));
     CPPUNIT_ASSERT(this->hasRelationProperties(source_multi, "4"));
 
     abstractRule->Disconnect(source_multi, "uid6");
     CPPUNIT_ASSERT(!this->hasRelationProperties(source_multi, "1"));
     CPPUNIT_ASSERT(!this->hasRelationProperties(source_multi, "2"));
     CPPUNIT_ASSERT(this->hasRelationProperties(source_multi, "4"));
 
     abstractRule->Disconnect(source_multi, "unkownRelationUID");
     CPPUNIT_ASSERT(!this->hasRelationProperties(source_multi, "1"));
     CPPUNIT_ASSERT(!this->hasRelationProperties(source_multi, "2"));
     CPPUNIT_ASSERT(this->hasRelationProperties(source_multi, "4"));
 
     abstractRule->Disconnect(source_otherTypeRule, dest_1);
     CPPUNIT_ASSERT_MESSAGE("Data of other rule type was removed.", !this->hasRelationProperties(source_otherTypeRule, "1"));
   }
 
+  void GetRIIPropertyKeyPath()
+  {
+    auto path = mitk::PropertyRelationRuleBase::GetRootKeyPath();
+    mitk::PropertyKeyPath referencePath({ "MITK", "Relations" });
+    CPPUNIT_ASSERT(referencePath == path);
+
+    path = mitk::PropertyRelationRuleBase::GetRIIPropertyKeyPath("a","1");
+    referencePath = { "MITK", "Relations", "1", "a" };
+    CPPUNIT_ASSERT(referencePath == path);
+
+    path = mitk::PropertyRelationRuleBase::GetRIIPropertyKeyPath("", "1");
+    referencePath = { "MITK", "Relations", "1"};
+    CPPUNIT_ASSERT(referencePath == path);
+
+    path = mitk::PropertyRelationRuleBase::GetRIIPropertyKeyPath("a", "");
+    referencePath = mitk::PropertyRelationRuleBase::GetRootKeyPath().AddAnyElement().AddElement("a");
+    CPPUNIT_ASSERT(referencePath == path);
+
+    path = mitk::PropertyRelationRuleBase::GetRIIRelationUIDPropertyKeyPath();
+    referencePath = mitk::PropertyRelationRuleBase::GetRootKeyPath().AddAnyElement().AddElement("relationUID");
+    CPPUNIT_ASSERT(referencePath == path);
+
+    path = mitk::PropertyRelationRuleBase::GetRIIRelationUIDPropertyKeyPath("1");
+    referencePath = { "MITK", "Relations", "1", "relationUID" };
+    CPPUNIT_ASSERT(referencePath == path);
+
+    path = mitk::PropertyRelationRuleBase::GetRIIRuleIDPropertyKeyPath();
+    referencePath = mitk::PropertyRelationRuleBase::GetRootKeyPath().AddAnyElement().AddElement("ruleID");
+    CPPUNIT_ASSERT(referencePath == path);
+
+    path = mitk::PropertyRelationRuleBase::GetRIIRuleIDPropertyKeyPath("1");
+    referencePath = { "MITK", "Relations", "1", "ruleID" };
+    CPPUNIT_ASSERT(referencePath == path);
+
+    path = mitk::PropertyRelationRuleBase::GetRIIDestinationUIDPropertyKeyPath();
+    referencePath = mitk::PropertyRelationRuleBase::GetRootKeyPath().AddAnyElement().AddElement("destinationUID");
+    CPPUNIT_ASSERT(referencePath == path);
+
+    path = mitk::PropertyRelationRuleBase::GetRIIDestinationUIDPropertyKeyPath("1");
+    referencePath = { "MITK", "Relations", "1", "destinationUID" };
+    CPPUNIT_ASSERT(referencePath == path);
+  }
+
+
 };
 
 MITK_TEST_SUITE_REGISTRATION(mitkPropertyRelationRuleBase)
diff --git a/Modules/DICOMReader/src/mitkDICOMTagsOfInterestHelper.cpp b/Modules/DICOMReader/src/mitkDICOMTagsOfInterestHelper.cpp
index 6b8c472847..689ccf67c2 100644
--- a/Modules/DICOMReader/src/mitkDICOMTagsOfInterestHelper.cpp
+++ b/Modules/DICOMReader/src/mitkDICOMTagsOfInterestHelper.cpp
@@ -1,199 +1,210 @@
 /*============================================================================
 
 The Medical Imaging Interaction Toolkit (MITK)
 
 Copyright (c) German Cancer Research Center (DKFZ)
 All rights reserved.
 
 Use of this source code is governed by a 3-clause BSD license that can be
 found in the LICENSE file.
 
 ============================================================================*/
 
 #include "mitkDICOMTagsOfInterestHelper.h"
 
 #include <mitkIDICOMTagsOfInterest.h>
 
 #include "usModuleContext.h"
 #include "usGetModuleContext.h"
 
 mitk::DICOMTagPathMapType::value_type MakeLegacyEntry(const std::string& propName, const mitk::DICOMTag& tag)
 {
   return std::make_pair(tag, propName);
 }
 
 mitk::DICOMTagPathMapType::value_type MakeEntry(const mitk::DICOMTagPath& tagPath)
 {
   return std::make_pair(tagPath, "");
 }
 
 mitk::DICOMTagPathMapType
 mitk::GetCurrentDICOMTagsOfInterest()
 {
   mitk::DICOMTagPathMapType result;
 
   std::vector<us::ServiceReference<mitk::IDICOMTagsOfInterest> > toiRegisters = us::GetModuleContext()->GetServiceReferences<mitk::IDICOMTagsOfInterest>();
   if (toiRegisters.empty())
   {
     // bad, no service found, cannot get tags of interest
     MITK_ERROR << "DICOM tag error: no service for DICOM tags of interest";
     return result;
   }
   else if (toiRegisters.size() > 1)
   {
     MITK_WARN << "DICOM tag error: multiple service for DICOM tags of interest found. Using just one.";
   }
 
   auto* toiRegister = us::GetModuleContext()->GetService<mitk::IDICOMTagsOfInterest>(toiRegisters.front());
   if (!toiRegister)
   {
     MITK_ERROR << "Service lookup error, cannot get DICOM tag of interest service ";
   }
 
   return toiRegister->GetTagsOfInterest();
 }
 
 mitk::DICOMTagPathMapType
 mitk::GetDefaultDICOMTagsOfInterest()
 {
   DICOMTagPathMapType result;
     //These tags are copied from DICOMSeriesReader. The old naming style (deprecated)
     //is kept for backwards compatibility until it is removed.
     //Below we have also already added the properties with the new naming style
 
     // Patient module
     /*dicom.patient.PatientsName*/ result.insert(MakeEntry(DICOMTag(0x0010, 0x0010)));
     /*dicom.patient.PatientID*/ result.insert(MakeEntry(DICOMTag(0x0010, 0x0020)));
     /*dicom.patient.PatientsBirthDate*/ result.insert(MakeEntry(DICOMTag(0x0010, 0x0030)));
     /*dicom.patient.PatientsSex*/ result.insert(MakeEntry(DICOMTag(0x0010, 0x0040)));
     /*dicom.patient.PatientsBirthTime*/ result.insert(MakeEntry(DICOMTag(0x0010, 0x0032)));
     /*dicom.patient.OtherPatientIDs*/ result.insert(MakeEntry(DICOMTag(0x0010, 0x1000)));
     /*dicom.patient.OtherPatientNames*/ result.insert(MakeEntry(DICOMTag(0x0010, 0x1001)));
     /*dicom.patient.EthnicGroup*/ result.insert(MakeEntry(DICOMTag(0x0010, 0x2160)));
     /*dicom.patient.PatientComments*/ result.insert(MakeEntry(DICOMTag(0x0010, 0x4000)));
     /*dicom.patient.PatientIdentityRemoved*/ result.insert(MakeEntry(DICOMTag(0x0012, 0x0062)));
     /*dicom.patient.DeIdentificationMethod*/ result.insert(MakeEntry(DICOMTag(0x0012, 0x0063)));
 
     // General Study module
     /*dicom.study.StudyInstanceUID*/ result.insert(MakeEntry(DICOMTag(0x0020, 0x000d)));
     /*dicom.study.StudyDate*/ result.insert(MakeEntry(DICOMTag(0x0008, 0x0020)));
     /*dicom.study.StudyTime*/ result.insert(MakeEntry(DICOMTag(0x0008, 0x0030)));
     /*dicom.study.ReferringPhysiciansName*/ result.insert(MakeEntry(DICOMTag(0x0008, 0x0090)));
     /*dicom.study.StudyID*/ result.insert(MakeEntry(DICOMTag(0x0020, 0x0010)));
     /*dicom.study.AccessionNumber*/ result.insert(MakeEntry(DICOMTag(0x0008, 0x0050)));
     /*dicom.study.StudyDescription*/ result.insert(MakeEntry(DICOMTag(0x0008, 0x1030)));
     /*dicom.study.PhysiciansOfRecord*/ result.insert(MakeEntry(DICOMTag(0x0008, 0x1048)));
     /*dicom.study.NameOfPhysicianReadingStudy*/ result.insert(MakeEntry(DICOMTag(0x0008, 0x1060)));
 
     // General Series module
     /*dicom.series.Modality*/ result.insert(MakeEntry(DICOMTag(0x0008, 0x0060)));
     /*dicom.series.SeriesInstanceUID*/ result.insert(MakeEntry(DICOMTag(0x0020, 0x000e)));
     /*dicom.series.SeriesNumber*/ result.insert(MakeEntry(DICOMTag(0x0020, 0x0011)));
     /*dicom.series.Laterality*/ result.insert(MakeEntry(DICOMTag(0x0020, 0x0060)));
     /*dicom.series.SeriesDate*/ result.insert(MakeEntry(DICOMTag(0x0008, 0x0021)));
     /*dicom.series.SeriesTime*/ result.insert(MakeEntry(DICOMTag(0x0008, 0x0031)));
     /*dicom.series.PerformingPhysiciansName*/ result.insert(MakeEntry(DICOMTag(0x0008, 0x1050)));
     /*dicom.series.ProtocolName*/ result.insert(MakeEntry(DICOMTag(0x0018, 0x1030)));
     /*dicom.series.SeriesDescription*/ result.insert(MakeEntry(DICOMTag(0x0008, 0x103e)));
     /*dicom.series.OperatorsName*/ result.insert(MakeEntry(DICOMTag(0x0008, 0x1070)));
     /*dicom.series.BodyPartExamined*/ result.insert(MakeEntry(DICOMTag(0x0018, 0x0015)));
     /*dicom.series.PatientPosition*/ result.insert(MakeEntry(DICOMTag(0x0018, 0x5100)));
     /*dicom.series.SmallestPixelValueInSeries*/ result.insert(MakeEntry(DICOMTag(0x0028, 0x0108)));
     /*dicom.series.LargestPixelValueInSeries*/ result.insert(MakeEntry(DICOMTag(0x0028, 0x0109)));
 
     // VOI LUT module
     /*dicom.voilut.WindowCenter*/ result.insert(MakeEntry(DICOMTag(0x0028, 0x1050)));
     /*dicom.voilut.WindowWidth*/ result.insert(MakeEntry(DICOMTag(0x0028, 0x1051)));
     /*dicom.voilut.WindowCenterAndWidthExplanation*/ result.insert(MakeEntry(DICOMTag(0x0028, 0x1055)));
 
     // Image Pixel module
     /*dicom.pixel.PhotometricInterpretation*/ result.insert(MakeEntry(DICOMTag(0x0028, 0x0004)));
     /*dicom.pixel.Rows*/ result.insert(MakeEntry(DICOMTag(0x0028, 0x0010)));
     /*dicom.pixel.Columns*/ result.insert(MakeEntry(DICOMTag(0x0028, 0x0011)));
 
     // Image Plane module
     /*dicom.PixelSpacing*/ result.insert(MakeEntry(DICOMTag(0x0028, 0x0030)));
     /*dicom.ImagerPixelSpacing*/ result.insert(MakeEntry(DICOMTag(0x0018, 0x1164)));
 
     //additional for RT
     /*dicom.RescaleIntercept*/ result.insert(MakeEntry(DICOMTag(0x0028, 0x1052)));
     /*dicom.RescaleSlope*/ result.insert(MakeEntry(DICOMTag(0x0028, 0x1053)));
     /*dicom.ManufacturerModelName*/ result.insert(MakeEntry(DICOMTag(0x0008, 0x1090)));
     /*dicom.ManufacturerName*/ result.insert(MakeEntry(DICOMTag(0x0008, 0x0070)));
     /*dicom.InstitutionName*/ result.insert(MakeEntry(DICOMTag(0x0008, 0x0080)));
     /*dicom.StationName*/ result.insert(MakeEntry(DICOMTag(0x0008, 0x1010)));
     /*dicom.DoseGridScaling*/ result.insert(MakeEntry(DICOMTag(0x3004, 0x000e)));
 
     //Additions for RTPLAN
     DICOMTagPath doseReferenceSequence;
     doseReferenceSequence.AddAnySelection(0x300A, 0x0010);
     DICOMTagPath fractionGroupSequence;
     fractionGroupSequence.AddAnySelection(0x300A, 0x0070);
     DICOMTagPath beamSequence;
     beamSequence.AddAnySelection(0x300A, 0x00B0);
     DICOMTagPath referencedStructureSetSequence;
     referencedStructureSetSequence.AddAnySelection(0x300C, 0x0060);
     result.insert(MakeEntry(DICOMTagPath(doseReferenceSequence).AddElement(0x300A, 0x0013))); //dicom.DoseReferenceSequence.DoseReferenceUID
     result.insert(MakeEntry(DICOMTagPath(doseReferenceSequence).AddElement(0x300A, 0x0016))); //dicom.DoseReferenceSequence.DoseReferenceDescription
     result.insert(MakeEntry(DICOMTagPath(doseReferenceSequence).AddElement(0x300A, 0x0026))); //dicom.DoseReferenceSequence.TargetPrescriptionDose
     result.insert(MakeEntry(DICOMTagPath(fractionGroupSequence).AddElement(0x300A, 0x0078))); //dicom.FractionGroupSequence.NumberOfFractionsPlanned
     result.insert(MakeEntry(DICOMTagPath(fractionGroupSequence).AddElement(0x300A, 0x0080))); //dicom.FractionGroupSequence.NumberOfBeams
     result.insert(MakeEntry(DICOMTagPath(beamSequence).AddElement(0x300A, 0x00C6)));          //dicom.BeamSequence.RadiationType
     result.insert(MakeEntry(DICOMTagPath(referencedStructureSetSequence).AddElement(0x0008, 0x1155))); //dicom.ReferencedStructureSetSequence.ReferencedSOPInstanceUID
 
     //Additions for RTSTRUCT
     DICOMTagPath structureSetROISequence;
     structureSetROISequence.AddAnySelection(0x3006, 0x0020);
     result.insert(MakeEntry(DICOMTagPath(structureSetROISequence).AddElement(0x3006, 0x0022))); //dicom.StructureSetROISequence.ROINumber
     result.insert(MakeEntry(DICOMTagPath(structureSetROISequence).AddElement(0x3006, 0x0026))); //dicom.StructureSetROISequence.ROIName
     result.insert(MakeEntry(DICOMTagPath(structureSetROISequence).AddElement(0x3006, 0x0024))); //dicom.StructureSetROISequence.ReferencedFrameOfReferenceUID
 
     //Additions for RTDOSE
     DICOMTagPath planReferenceSequence;
     planReferenceSequence.AddAnySelection(0x300C, 0x0002);
     result.insert(MakeEntry(DICOMTagPath(planReferenceSequence).AddElement(0x0008, 0x1155))); //dicom.PlanReferenceSequence.ReferencedSOPInstanceUID
 
     //Additions for PET
     DICOMTagPath radioPharmaRootTag;
     radioPharmaRootTag.AddAnySelection(0x0054, 0x0016);
     DICOMTagPath radioNuclideRootTag(radioPharmaRootTag);
     radioNuclideRootTag.AddAnySelection(0x0054, 0x0300);
 
     result.insert(MakeEntry(DICOMTagPath(radioPharmaRootTag).AddElement(0x0018, 0x0031))); //dicom.pet.Radiopharmaceutical
     result.insert(MakeEntry(DICOMTagPath(radioPharmaRootTag).AddElement(0x0018, 0x1072))); //dicom.pet.RadiopharmaceuticalStartTime
     result.insert(MakeEntry(DICOMTagPath(radioPharmaRootTag).AddElement(0x0018, 0x1074))); //dicom.pet.RadionuclideTotalDose
     result.insert(MakeEntry(DICOMTagPath(radioPharmaRootTag).AddElement(0x0018, 0x1075))); //dicom.pet.RadionuclideHalfLife
     result.insert(MakeEntry(DICOMTagPath(radioPharmaRootTag).AddElement(0x0018, 0x1076))); //dicom.pet.RadionuclidePositronFraction
 
     result.insert(MakeEntry(DICOMTagPath(radioNuclideRootTag).AddElement(0x0008, 0x0100))); //dicom.pet.Radionuclide.CodeValue
     result.insert(MakeEntry(DICOMTagPath(radioNuclideRootTag).AddElement(0x0008, 0x0102))); //dicom.pet.Radionuclide.CodingSchemeDesignator
-    result.insert(MakeEntry(DICOMTagPath(radioNuclideRootTag).AddElement(0x0008, 0x0104))); //dicom.pet.Radionuclide.CodemManing
+    result.insert(MakeEntry(DICOMTagPath(radioNuclideRootTag).AddElement(0x0008, 0x0104))); //dicom.pet.Radionuclide.CodeMeaning
 
     result.insert(MakeEntry(DICOMTag(0x0054, 0x1001))); //dicom.pet.RadioactivityUnits
     result.insert(MakeEntry(DICOMTag(0x0054, 0x1102))); //dicom.pet.DecayCorrection
     result.insert(MakeEntry(DICOMTag(0x0054, 0x1321))); //dicom.pet.DecayFactor
     result.insert(MakeEntry(DICOMTag(0x0054, 0x1300))); //dicom.pet.FrameReferenceTime
 
     result.insert(MakeEntry(DICOMTag(0x0010, 0x1030))); //dicom.patient.PatientWeight
     result.insert(MakeEntry(DICOMTag(0x0010, 0x1020))); //dicom.patient.PatientSize
 
     //Other interesting acquisition correlated information
     result.insert(MakeEntry(DICOMTag(0x0008, 0x0022))); //dicom.acquisition date
     result.insert(MakeEntry(DICOMTag(0x0008, 0x0032))); //dicom.acquisition time
     result.insert(MakeEntry(DICOMTag(0x0008, 0x002a))); //dicom.acquisition datetime
     result.insert(MakeEntry(DICOMTag(0x0008, 0x0080))); //dicom.Modality
     result.insert(MakeEntry(DICOMTag(0x0018, 0x002a))); //dicom.Sequence Name
     result.insert(MakeEntry(DICOMTag(0x0018, 0x0020))); //dicom.Scanning Sequence
     result.insert(MakeEntry(DICOMTag(0x0018, 0x0021))); //dicom.Sequence Variant
     result.insert(MakeEntry(DICOMTag(0x0018, 0x0080))); //dicom.TR
     result.insert(MakeEntry(DICOMTag(0x0018, 0x0081))); //dicom.TE
     result.insert(MakeEntry(DICOMTag(0x0018, 0x1310))); //dicom.Acquisition Matrix
     result.insert(MakeEntry(DICOMTag(0x0018, 0x0087))); //dicom.Magnetic Field Strength
 
     //SOP
     result.insert(MakeEntry(DICOMTag(0x0008, 0x0018))); //SOP Instance UID
     result.insert(MakeEntry(DICOMTag(0x0020, 0x0013))); //Instance number
     result.insert(MakeEntry(DICOMTag(0x0020, 0x1041))); //Slice location
 
+    //Tags that document relations to other elements
+    DICOMTagPath sourceImageRefRootTag;
+    sourceImageRefRootTag.AddAnySelection(0x0008, 0x2112);
+    result.insert(MakeEntry(DICOMTagPath(sourceImageRefRootTag).AddElement(0x0008, 0x1155))); //dicom.SourceImage.ReferenceSOPInstanceUID
+    result.insert(MakeEntry(DICOMTagPath(sourceImageRefRootTag).AddElement(0x0008, 0x1150))); //dicom.SourceImage.ReferenceSOPClassUID
+    DICOMTagPath sourceImageRefPurposeRootTag(sourceImageRefRootTag);
+    sourceImageRefPurposeRootTag.AddAnySelection(0x0040, 0xa170);
+    result.insert(MakeEntry(DICOMTagPath(sourceImageRefPurposeRootTag).AddElement(0x0008, 0x0104))); //dicom.SourceImage.Purpose.CodeMeaning
+    result.insert(MakeEntry(DICOMTagPath(sourceImageRefPurposeRootTag).AddElement(0x0008, 0x0100))); //dicom.SourceImage.Purpose.CodeValue
+    result.insert(MakeEntry(DICOMTagPath(sourceImageRefPurposeRootTag).AddElement(0x0008, 0x0102))); //dicom.SourceImage.Purpose.CodeSchemeDesignator
+
     return result;
 };