[core] Change attribute name and label properties

Adding new properties and updating the call to previous ones.
Properties are now :
* label : getLabel
* fullLabel : getFullLabel
* fullLabelToNode : getFullLabelToNode
* fullLabelToGraph : getFullLabelToGraph

Same for the name.

meshroom/core/attribute.py

@@ -71,25 +71,30 @@ class Attribute(BaseObject):
     def root(self):
         return self._root() if self._root else None
 
-    def absoluteName(self):
-        return '{}.{}.{}'.format(self.node.graph.name, self.node.name, self._name)
-
-    def getFullName(self):
-        """ Name inside the Graph: nodeName.name """
-        if isinstance(self.root, ListAttribute):
-            return '{}[{}]'.format(self.root.getFullName(), self.root.index(self))
-        elif isinstance(self.root, GroupAttribute):
-            return '{}.{}'.format(self.root.getFullName(), self._name)
-        return '{}.{}'.format(self.node.name, self._name)
-
-    def asLinkExpr(self):
-        """ Return link expression for this Attribute """
-        return "{" + self.getFullName() + "}"
-
     def getName(self):
         """ Attribute name """
         return self._name
 
+    def getFullName(self):
+        """ Name inside the Graph: groupName.name """
+        if isinstance(self.root, ListAttribute):
+            return '{}[{}]'.format(self.root.getFullName(), self.root.index(self))
+        elif isinstance(self.root, GroupAttribute):
+            return '{}.{}'.format(self.root.getFullName(), self.getName())
+        return self.getName()
+
+    def getFullNameToNode(self):
+        """ Name inside the Graph: nodeName.groupName.name """
+        return '{}.{}'.format(self.node.name, self.getFullName())
+
+    def getFullNameToGraph(self):
+        """ Name inside the Graph: graphName.nodeName.groupName.name """
+        return '{}.{}'.format(self.node.graph.name, self.getFullNameToNode())
+
+    def asLinkExpr(self):
+        """ Return link expression for this Attribute """
+        return "{" + self.getFullNameToNode() + "}"
+
     def getType(self):
         return self.attributeDesc.__class__.__name__
 
@@ -102,6 +107,22 @@ class Attribute(BaseObject):
     def getLabel(self):
         return self._label
 
+    def getFullLabel(self):
+        """ Full Label includes the name of all parent groups, e.g. 'groupLabel subGroupLabel Label' """
+        if isinstance(self.root, ListAttribute):
+            return self.root.getFullLabel()
+        elif isinstance(self.root, GroupAttribute):
+            return '{} {}'.format(self.root.getFullLabel(), self.getLabel())
+        return self.getLabel()
+
+    def getFullLabelToNode(self):
+        """ Label inside the Graph: nodeLabel groupLabel Label """
+        return '{} {}'.format(self.node.label, self.getFullLabel())
+
+    def getFullLabelToGraph(self):
+        """ Label inside the Graph: graphName nodeLabel groupLabel Label """
+        return '{} {}'.format(self.node.graph.name, self.getFullLabelToNode())
+
     def getEnabled(self):
         if isinstance(self.desc.enabled, types.FunctionType):
             try:
@@ -265,7 +286,12 @@ class Attribute(BaseObject):
 
     name = Property(str, getName, constant=True)
     fullName = Property(str, getFullName, constant=True)
+    fullNameToNode = Property(str, getFullNameToNode, constant=True)
+    fullNameToGraph = Property(str, getFullNameToGraph, constant=True)
     label = Property(str, getLabel, constant=True)
+    fullLabel = Property(str, getFullLabel, constant=True)
+    fullLabelToNode = Property(str, getFullLabelToNode, constant=True)
+    fullLabelToGraph = Property(str, getFullLabelToGraph, constant=True)
     type = Property(str, getType, constant=True)
     baseType = Property(str, getType, constant=True)
     isReadOnly = Property(bool, _isReadOnly, constant=True)

meshroom/core/graph.py

@@ -415,7 +415,7 @@ class Graph(BaseObject):
     def removeNode(self, nodeName):
         """
         Remove the node identified by 'nodeName' from the graph
-        and return in and out edges removed by this operation in two dicts {dstAttr.getFullName(), srcAttr.getFullName()}
+        and return in and out edges removed by this operation in two dicts {dstAttr.getFullNameToNode(), srcAttr.getFullNameToNode()}
         """
         node = self.node(nodeName)
         inEdges = {}
@@ -425,10 +425,10 @@ class Graph(BaseObject):
         with GraphModification(self):
             for edge in self.nodeOutEdges(node):
                 self.removeEdge(edge.dst)
-                outEdges[edge.dst.getFullName()] = edge.src.getFullName()
+                outEdges[edge.dst.getFullNameToNode()] = edge.src.getFullNameToNode()
             for edge in self.nodeInEdges(node):
                 self.removeEdge(edge.dst)
-                inEdges[edge.dst.getFullName()] = edge.src.getFullName()
+                inEdges[edge.dst.getFullNameToNode()] = edge.src.getFullNameToNode()
 
             node.alive = False
             self._nodes.remove(node)
@@ -583,7 +583,7 @@ class Graph(BaseObject):
         if srcAttr.node.graph != self or dstAttr.node.graph != self:
             raise RuntimeError('The attributes of the edge should be part of a common graph.')
         if dstAttr in self.edges.keys():
-            raise RuntimeError('Destination attribute "{}" is already connected.'.format(dstAttr.getFullName()))
+            raise RuntimeError('Destination attribute "{}" is already connected.'.format(dstAttr.getFullNameToNode()))
         edge = Edge(srcAttr, dstAttr)
         self.edges.add(edge)
         self.markNodesDirty(dstAttr.node)
@@ -600,7 +600,7 @@ class Graph(BaseObject):
     @changeTopology
     def removeEdge(self, dstAttr):
         if dstAttr not in self.edges.keys():
-            raise RuntimeError('Attribute "{}" is not connected'.format(dstAttr.getFullName()))
+            raise RuntimeError('Attribute "{}" is not connected'.format(dstAttr.getFullNameToNode()))
         edge = self.edges.pop(dstAttr)
         self.markNodesDirty(dstAttr.node)
         dstAttr.valueChanged.emit()
@@ -1202,4 +1202,3 @@ def loadGraph(filepath):
     graph.load(filepath)
     graph.update()
     return graph
-

meshroom/ui/commands.py

@@ -197,10 +197,10 @@ class DuplicateNodesCommand(GraphCommand):
 class SetAttributeCommand(GraphCommand):
     def __init__(self, graph, attribute, value, parent=None):
         super(SetAttributeCommand, self).__init__(graph, parent)
-        self.attrName = attribute.getFullName()
+        self.attrName = attribute.getFullNameToNode()
         self.value = value
         self.oldValue = attribute.getExportValue()
-        self.setText("Set Attribute '{}'".format(attribute.getFullName()))
+        self.setText("Set Attribute '{}'".format(attribute.getFullNameToNode()))
 
     def redoImpl(self):
         if self.value == self.oldValue:
@@ -215,8 +215,8 @@ class SetAttributeCommand(GraphCommand):
 class AddEdgeCommand(GraphCommand):
     def __init__(self, graph, src, dst, parent=None):
         super(AddEdgeCommand, self).__init__(graph, parent)
-        self.srcAttr = src.getFullName()
+        self.srcAttr = src.getFullNameToNode()
-        self.dstAttr = dst.getFullName()
+        self.dstAttr = dst.getFullNameToNode()
         self.setText("Connect '{}'->'{}'".format(self.srcAttr, self.dstAttr))
 
         if src.baseType != dst.baseType:
@@ -233,8 +233,8 @@ class AddEdgeCommand(GraphCommand):
 class RemoveEdgeCommand(GraphCommand):
     def __init__(self, graph, edge, parent=None):
         super(RemoveEdgeCommand, self).__init__(graph, parent)
-        self.srcAttr = edge.src.getFullName()
+        self.srcAttr = edge.src.getFullNameToNode()
-        self.dstAttr = edge.dst.getFullName()
+        self.dstAttr = edge.dst.getFullNameToNode()
         self.setText("Disconnect '{}'->'{}'".format(self.srcAttr, self.dstAttr))
 
     def redoImpl(self):
@@ -250,7 +250,7 @@ class ListAttributeAppendCommand(GraphCommand):
     def __init__(self, graph, listAttribute, value, parent=None):
         super(ListAttributeAppendCommand, self).__init__(graph, parent)
         assert isinstance(listAttribute, ListAttribute)
-        self.attrName = listAttribute.getFullName()
+        self.attrName = listAttribute.getFullNameToNode()
         self.index = None
         self.count = 1
         self.value = value if value else None
@@ -276,10 +276,10 @@ class ListAttributeRemoveCommand(GraphCommand):
         super(ListAttributeRemoveCommand, self).__init__(graph, parent)
         listAttribute = attribute.root
         assert isinstance(listAttribute, ListAttribute)
-        self.listAttrName = listAttribute.getFullName()
+        self.listAttrName = listAttribute.getFullNameToNode()
         self.index = listAttribute.index(attribute)
         self.value = attribute.getExportValue()
-        self.setText("Remove {}".format(attribute.getFullName()))
+        self.setText("Remove {}".format(attribute.getFullNameToNode()))
 
     def redoImpl(self):
         listAttribute = self.graph.attribute(self.listAttrName)

meshroom/ui/graph.py

@@ -618,14 +618,14 @@ class UIGraph(QObject):
     @Slot(Attribute, Attribute)
     def addEdge(self, src, dst):
         if isinstance(dst, ListAttribute) and not isinstance(src, ListAttribute):
-            with self.groupedGraphModification("Insert and Add Edge on {}".format(dst.getFullName())):
+            with self.groupedGraphModification("Insert and Add Edge on {}".format(dst.getFullNameToNode())):
                 self.appendAttribute(dst)
                 self._addEdge(src, dst.at(-1))
         else:
             self._addEdge(src, dst)
 
     def _addEdge(self, src, dst):
-        with self.groupedGraphModification("Connect '{}'->'{}'".format(src.getFullName(), dst.getFullName())):
+        with self.groupedGraphModification("Connect '{}'->'{}'".format(src.getFullNameToNode(), dst.getFullNameToNode())):
             if dst in self._graph.edges.keys():
                 self.removeEdge(self._graph.edge(dst))
             self.push(commands.AddEdgeCommand(self._graph, src, dst))
@@ -633,7 +633,7 @@ class UIGraph(QObject):
     @Slot(Edge)
     def removeEdge(self, edge):
         if isinstance(edge.dst.root, ListAttribute):
-            with self.groupedGraphModification("Remove Edge and Delete {}".format(edge.dst.getFullName())):
+            with self.groupedGraphModification("Remove Edge and Delete {}".format(edge.dst.getFullNameToNode())):
                 self.push(commands.RemoveEdgeCommand(self._graph, edge))
                 self.removeAttribute(edge.dst)
         else: