Add internal attributes in "Notes" tab

meshroom/core/attribute.py

@@ -143,6 +143,10 @@ def setEnabled(self, v):
         self._enabled = v
         self.enabledChanged.emit()
 
+    def getUidIgnoreValue(self):
+        """ Value for which the attribute should be ignored during the UID computation. """
+        return self.attributeDesc.uidIgnoreValue
+
     def _get_value(self):
         if self.isLink:
             return self.getLinkParam().value
@@ -168,6 +172,10 @@ def _set_value(self, value):
         # TODO: only update the graph if this attribute participates to a UID
         if self.isInput:
             self.requestGraphUpdate()
+            # TODO: only call update of the node if the attribute is internal
+            # Internal attributes are set as inputs
+            self.requestNodeUpdate()
+
         self.valueChanged.emit()
 
     def upgradeValue(self, exportedValue):
@@ -181,6 +189,12 @@ def requestGraphUpdate(self):
             self.node.graph.markNodesDirty(self.node)
             self.node.graph.update()
 
+    def requestNodeUpdate(self):
+        # Update specific node information that do not affect the rest of the graph
+        # (like internal attributes)
+        if self.node:
+            self.node.updateInternalAttributes()
+
     @property
     def isOutput(self):
         return self._isOutput
@@ -323,6 +337,7 @@ def updateInternals(self):
     node = Property(BaseObject, node.fget, constant=True)
     enabledChanged = Signal()
     enabled = Property(bool, getEnabled, setEnabled, notify=enabledChanged)
+    uidIgnoreValue = Property(Variant, getUidIgnoreValue, constant=True)
 
 
 def raiseIfLink(func):

meshroom/core/desc.py

@@ -14,7 +14,7 @@ class Attribute(BaseObject):
     """
     """
 
-    def __init__(self, name, label, description, value, advanced, semantic, uid, group, enabled):
+    def __init__(self, name, label, description, value, advanced, semantic, uid, group, enabled, uidIgnoreValue=None):
         super(Attribute, self).__init__()
         self._name = name
         self._label = label
@@ -25,6 +25,7 @@ def __init__(self, name, label, description, value, advanced, semantic, uid, gro
         self._advanced = advanced
         self._enabled = enabled
         self._semantic = semantic
+        self._uidIgnoreValue = uidIgnoreValue
 
     name = Property(str, lambda self: self._name, constant=True)
     label = Property(str, lambda self: self._label, constant=True)
@@ -35,6 +36,7 @@ def __init__(self, name, label, description, value, advanced, semantic, uid, gro
     advanced = Property(bool, lambda self: self._advanced, constant=True)
     enabled = Property(Variant, lambda self: self._enabled, constant=True)
     semantic = Property(str, lambda self: self._semantic, constant=True)
+    uidIgnoreValue = Property(Variant, lambda self: self._uidIgnoreValue, constant=True)
     type = Property(str, lambda self: self.__class__.__name__, constant=True)
 
     def validateValue(self, value):
@@ -201,8 +203,9 @@ def retrieveChildrenUids(self):
 class Param(Attribute):
     """
     """
-    def __init__(self, name, label, description, value, uid, group, advanced, semantic, enabled):
-        super(Param, self).__init__(name=name, label=label, description=description, value=value, uid=uid, group=group, advanced=advanced, semantic=semantic, enabled=enabled)
+    def __init__(self, name, label, description, value, uid, group, advanced, semantic, enabled, uidIgnoreValue=None):
+        super(Param, self).__init__(name=name, label=label, description=description, value=value, uid=uid, group=group, advanced=advanced, semantic=semantic, enabled=enabled,
+            uidIgnoreValue=uidIgnoreValue)
 
 
 class File(Attribute):
@@ -329,8 +332,9 @@ def checkValueTypes(self):
 class StringParam(Param):
     """
     """
-    def __init__(self, name, label, description, value, uid, group='allParams', advanced=False, semantic='', enabled=True):
-        super(StringParam, self).__init__(name=name, label=label, description=description, value=value, uid=uid, group=group, advanced=advanced, semantic=semantic, enabled=enabled)
+    def __init__(self, name, label, description, value, uid, group='allParams', advanced=False, semantic='', enabled=True, uidIgnoreValue=None):
+        super(StringParam, self).__init__(name=name, label=label, description=description, value=value, uid=uid, group=group, advanced=advanced, semantic=semantic, enabled=enabled,
+            uidIgnoreValue=uidIgnoreValue)
 
     def validateValue(self, value):
         if not isinstance(value, str):
@@ -343,6 +347,19 @@ def checkValueTypes(self):
         return ""
 
 
+class ColorParam(Param):
+    """
+    """
+    def __init__(self, name, label, description, value, uid, group='allParams', advanced=False, semantic='', enabled=True):
+        super(ColorParam, self).__init__(name=name, label=label, description=description, value=value, uid=uid, group=group, advanced=advanced, semantic=semantic, enabled=enabled)
+
+    def validateValue(self, value):
+        if not isinstance(value, str) or len(value.split(" ")) > 1:
+            raise ValueError('ColorParam value should be a string containing either an SVG name or an hexadecimal '
+                             'color code (param: {}, value: {}, type: {})'.format(self.name, value, type(value)))
+        return value
+
+
 class Level(Enum):
     NONE = 0
     NORMAL = 1
@@ -485,6 +502,43 @@ class Node(object):
     ram = Level.NORMAL
     packageName = ''
     packageVersion = ''
+    internalInputs = [
+        StringParam(
+            name="invalidation",
+            label="Invalidation Message",
+            description="A message that will invalidate the node's output folder.\n"
+                        "This is useful for development, we can invalidate the output of the node when we modify the code.\n"
+                        "It is displayed in bold font in the invalidation/comment messages tooltip.",
+            value="",
+            semantic="multiline",
+            uid=[0],
+            advanced=True,
+            uidIgnoreValue="",  # If the invalidation string is empty, it does not participate to the node's UID
+        ),
+        StringParam(
+            name="comment",
+            label="Comments",
+            description="User comments describing this specific node instance.\n"
+                        "It is displayed in regular font in the invalidation/comment messages tooltip.",
+            value="",
+            semantic="multiline",
+            uid=[],
+        ),
+        StringParam(
+            name="label",
+            label="Node's Label",
+            description="Customize the default label (to replace the technical name of the node instance).",
+            value="",
+            uid=[],
+        ),
+        ColorParam(
+            name="color",
+            label="Color",
+            description="Custom color for the node (SVG name or hexadecimal code).",
+            value="",
+            uid=[],
+        )
+    ]
     inputs = []
     outputs = []
     size = StaticNodeSize(1)

meshroom/core/graph.py

@@ -687,9 +687,24 @@ def attribute(self, fullName):
         # type: (str) -> Attribute
         """
         Return the attribute identified by the unique name 'fullName'.
+        If it does not exist, return None.
         """
         node, attribute = fullName.split('.', 1)
-        return self.node(node).attribute(attribute)
+        if self.node(node).hasAttribute(attribute):
+            return self.node(node).attribute(attribute)
+        return None
+
+    @Slot(str, result=Attribute)
+    def internalAttribute(self, fullName):
+        # type: (str) -> Attribute
+        """
+        Return the internal attribute identified by the unique name 'fullName'.
+        If it does not exist, return None.
+        """
+        node, attribute = fullName.split('.', 1)
+        if self.node(node).hasInternalAttribute(attribute):
+            return self.node(node).internalAttribute(attribute)
+        return None
 
     @staticmethod
     def getNodeIndexFromName(name):
@@ -1221,27 +1236,42 @@ def save(self, filepath=None, setupProjectFile=True, template=False):
 
     def getNonDefaultInputAttributes(self):
         """
-        Instead of getting all the inputs attribute keys, only get the keys of
+        Instead of getting all the inputs and internal attribute keys, only get the keys of
         the attributes whose value is not the default one.
         The output attributes, UIDs, parallelization parameters and internal folder are
         not relevant for templates, so they are explicitly removed from the returned dictionary.
 
         Returns:
             dict: self.toDict() with the output attributes, UIDs, parallelization parameters, internal folder
-            and input attributes with default values removed
+            and input/internal attributes with default values removed
         """
         graph = self.toDict()
         for nodeName in graph.keys():
             node = self.node(nodeName)
 
             inputKeys = list(graph[nodeName]["inputs"].keys())
 
+            internalInputKeys = []
+            internalInputs = graph[nodeName].get("internalInputs", None)
+            if internalInputs:
+                internalInputKeys = list(internalInputs.keys())
+
             for attrName in inputKeys:
                 attribute = node.attribute(attrName)
                 # check that attribute is not a link for choice attributes
                 if attribute.isDefault and not attribute.isLink:
                     del graph[nodeName]["inputs"][attrName]
 
+            for attrName in internalInputKeys:
+                attribute = node.internalAttribute(attrName)
+                # check that internal attribute is not a link for choice attributes
+                if attribute.isDefault and not attribute.isLink:
+                    del graph[nodeName]["internalInputs"][attrName]
+
+            # If all the internal attributes are set to their default values, remove the entry
+            if len(graph[nodeName]["internalInputs"]) == 0:
+                del graph[nodeName]["internalInputs"]
+
             del graph[nodeName]["outputs"]
             del graph[nodeName]["uids"]
             del graph[nodeName]["internalFolder"]