Add support for backdrops in the Graph

meshroom/core/desc/__init__.py

@@ -33,11 +33,13 @@
     StaticNodeSize,
 )
 from .node import (
-    MrNodeType,
     AVCommandLineNode,
     BaseNode,
+    BackdropNode,
     CommandLineNode,
     InitNode,
     InputNode,
+    InternalAttributesFactory,
+    MrNodeType,
     Node,
 )

meshroom/core/desc/node.py

@@ -15,7 +15,7 @@
 from meshroom.core.utils import VERBOSE_LEVEL
 
 from .computation import Level, StaticNodeSize
-from .attribute import StringParam, ColorParam, ChoiceParam
+from .attribute import Attribute, ChoiceParam, ColorParam, IntParam, StringParam
 
 _MESHROOM_ROOT = Path(meshroom.__file__).parent.parent.as_posix()
 _MESHROOM_COMPUTE = (Path(_MESHROOM_ROOT) / "bin" / "meshroom_compute").as_posix()
@@ -56,29 +56,11 @@ class MrNodeType(enum.Enum):
     NODE = enum.auto()
     COMMANDLINE = enum.auto()
     INPUT = enum.auto()
+    BACKDROP = enum.auto()
 
 
-class BaseNode(object):
-    """
-    """
-    cpu = Level.NORMAL
-    gpu = Level.NONE
-    ram = Level.NORMAL
-    packageName = ""
-    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",
-            advanced=True,
-            uidIgnoreValue="",  # If the invalidation string is empty, it does not participate to the node's UID
-        ),
+class InternalAttributesFactory:
+    BASIC = [
         StringParam(
             name="comment",
             label="Comments",
@@ -113,6 +95,84 @@ class BaseNode(object):
             invalidate=False,
         )
     ]
+
+    INVALIDATION = [
+        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",
+            advanced=True,
+            uidIgnoreValue="",  # If the invalidation string is empty, it does not participate to the node's UID
+        ),
+    ]
+
+    RESIZABLE = [
+        IntParam(
+            name="fontSize",
+            label="Font Size",
+            description="Size of the font used to display the comments.",
+            value=12,
+            range=(6, 100, 1),
+            invalidate=False,
+        ),
+        ColorParam(
+            name="fontColor",
+            label="Font Color",
+            description="Color of the font used to display the comments (SVG name or hexadecimal code).",
+            value="",
+            invalidate=False,
+        ),
+        IntParam(
+            name="nodeWidth",
+            label="Node Width",
+            description="Width of the node in the graph editor.",
+            value=600,
+            range=None,
+            invalidate=False,
+            enabled=False,  # Hidden
+        ),
+        IntParam(
+            name="nodeHeight",
+            label="Node Height",
+            description="Height of the node in the graph editor.",
+            value=400,
+            range=None,
+            invalidate=False,
+            enabled=False,  # Hidden
+        ),
+    ]
+
+    @classmethod
+    def getInternalAttributes(cls, mrNodeType: MrNodeType) -> list[Attribute]:
+        paramMap = {
+            MrNodeType.NONE: cls.BASIC,
+            MrNodeType.BASENODE: cls.INVALIDATION + cls.BASIC,
+            MrNodeType.NODE: cls.INVALIDATION + cls.BASIC,
+            MrNodeType.COMMANDLINE: cls.INVALIDATION + cls.BASIC,
+            MrNodeType.INPUT: cls.BASIC,
+            MrNodeType.BACKDROP: cls.BASIC + cls.RESIZABLE,
+        }
+
+        return paramMap.get(mrNodeType)
+
+
+class BaseNode(object):
+    """
+    """
+    cpu = Level.NORMAL
+    gpu = Level.NONE
+    ram = Level.NORMAL
+    packageName = ""
+    _mrNodeType: MrNodeType = MrNodeType.BASENODE
+
+    internalInputs = InternalAttributesFactory.getInternalAttributes(_mrNodeType)
+
     inputs = []
     outputs = []
     size = StaticNodeSize(1)
@@ -130,7 +190,7 @@ def __init__(self):
         self.sourceCodeFolder = Path(getfile(self.__class__)).parent.resolve().as_posix()
 
     def getMrNodeType(self):
-        return MrNodeType.BASENODE
+        return self._mrNodeType
 
     def upgradeAttributeValues(self, attrValues, fromVersion):
         return attrValues
@@ -286,24 +346,50 @@ class InputNode(BaseNode):
     """
     Node that does not need to be processed, it is just a placeholder for inputs.
     """
+    _mrNodeType: MrNodeType = MrNodeType.INPUT
+    internalInputs = InternalAttributesFactory.getInternalAttributes(_mrNodeType)
+
     def __init__(self):
         super(InputNode, self).__init__()
 
     def getMrNodeType(self):
-        return MrNodeType.INPUT
+        return self._mrNodeType
 
     def processChunk(self, chunk):
         pass
 
+    def process(self, node):
+        pass
+
+class BackdropNode(BaseNode):
+    """
+    Node that does not need to be processed, it is just a placeholder for grouping other nodes.
+    """
+    _mrNodeType: MrNodeType = MrNodeType.BACKDROP
+    internalInputs = InternalAttributesFactory.getInternalAttributes(_mrNodeType)
+
+    def __init__(self):
+        super(BackdropNode, self).__init__()
+
+    def getMrNodeType(self):
+        return self._mrNodeType
+
+    def processChunk(self, chunk):
+        pass
+
+    def process(self, node):
+        pass
+
 
 class Node(BaseNode):
     pythonExecutable = "python"
+    _mrNodeType: MrNodeType = MrNodeType.NODE
 
     def __init__(self):
         super(Node, self).__init__()
 
     def getMrNodeType(self):
-        return MrNodeType.NODE
+        return self._mrNodeType
 
     def processChunkInEnvironment(self, chunk):
         meshroomComputeCmd = f"{chunk.node.nodeDesc.pythonExecutable} {_MESHROOM_COMPUTE}" + \
@@ -326,12 +412,13 @@ class CommandLineNode(BaseNode):
     commandLine = ""  # need to be defined on the node
     parallelization = None
     commandLineRange = ""
+    _mrNodeType: MrNodeType = MrNodeType.COMMANDLINE
 
     def __init__(self):
         super(CommandLineNode, self).__init__()
 
     def getMrNodeType(self):
-        return MrNodeType.COMMANDLINE
+        return self._mrNodeType
 
     def buildCommandLine(self, chunk) -> str:
         cmdLineVars = chunk.node.createCmdLineVars()

meshroom/core/graph.py

@@ -20,7 +20,7 @@
 from meshroom.core.exception import GraphCompatibilityError, InvalidEdgeError, StopGraphVisit, StopBranchVisit, CyclicDependencyError
 from meshroom.core.graphIO import GraphIO, GraphSerializer, TemplateGraphSerializer, PartialGraphSerializer
 from meshroom.core.node import BaseNode, Status, Node, CompatibilityNode
-from meshroom.core.nodeFactory import nodeFactory
+from meshroom.core.nodeFactory import nodeFactory, getNodeConstructor
 from meshroom.core.mtyping import PathLike
 from meshroom.core.submitter import BaseSubmittedJob, jobManager
 
@@ -693,7 +693,7 @@ def addNewNode(
         if name and name in self._nodes.keys():
             name = self._createUniqueNodeName(name)
 
-        node = self.addNode(Node(nodeType, position=position, **kwargs), uniqueName=name)
+        node = self.addNode(getNodeConstructor(nodeType, position=position, **kwargs), uniqueName=name)
         node.updateInternals()
         self._triggerNodeCreatedCallback([node])
         return node

meshroom/core/graphIO.py

@@ -184,8 +184,9 @@ def serializeNode(self, node: Node) -> dict:
 
         # Override input attributes with custom serialization logic, to handle attributes
         # connected to nodes that are not in the list of nodes to serialize.
-        for attributeName in nodeData["inputs"]:
-            nodeData["inputs"][attributeName] = self._serializeAttribute(node.attribute(attributeName))
+        if nodeData.get("inputs", None):
+            for attributeName in nodeData["inputs"]:
+                nodeData["inputs"][attributeName] = self._serializeAttribute(node.attribute(attributeName))
 
         # Clear UID for non-compatibility nodes, as the custom attribute serialization
         # can be impacting the UID by removing connections to missing nodes.