Added Backdrop Node for Meshroom graph

meshroom/core/__init__.py

@@ -20,6 +20,7 @@
 
 from meshroom.core.submitter import BaseSubmitter
 from . import desc
+from .desc import builtins
 
 # Setup logging
 logging.basicConfig(format='[%(asctime)s][%(levelname)s] %(message)s', level=logging.INFO)
@@ -36,7 +37,7 @@
 
 def hashValue(value):
     """ Hash 'value' using sha1. """
     hashObject = hashlib.sha1(str(value).encode('utf-8'))
     return hashObject.hexdigest()
 
 
@@ -337,6 +338,9 @@
     for f in nodesFolders:
         loadAllNodes(folder=f)
 
+    # Load all of the builtin Node Plugins
+    initBuiltinNodePlugins()
+
 
 def initSubmitters():
     meshroomFolder = os.path.dirname(os.path.dirname(__file__))
@@ -357,3 +361,8 @@
             loadPipelineTemplates(f)
         else:
             logging.error("Pipeline templates folder '{}' does not exist.".format(f))
+
+def initBuiltinNodePlugins():
+    """ Registers the Builtin plugins for Meshroom.
+    """
+    registerNodeType(builtins.Backdrop)

meshroom/core/desc/builtins.py

@@ -0,0 +1,12 @@
+""" Defines the Built in Plugins.
+"""
+from .node import InputNode, AttributeFactory, Traits
+
+
+class Backdrop(InputNode):
+    """ A Backdrop for other nodes.
+    """
+
+    internalInputs = AttributeFactory.getInternalParameters(Traits.RESIZABLE)
+
+    category = "Utils"

meshroom/core/desc/node.py

@@ -1,34 +1,33 @@
+import enum
 import os
 import psutil
 import shlex
+from typing import List
 
 from .computation import Level, StaticNodeSize
-from .attribute import StringParam, ColorParam
+from .attribute import Attribute, StringParam, ColorParam, IntParam, FloatParam
 
 from meshroom.core import cgroup
 
 
-class Node(object):
-    """
+class Traits(enum.IntEnum):
+    """ Describes the characteristics of the Attribute Groups.
     """
-    internalFolder = '{cache}/{nodeType}/{uid}/'
-    cpu = Level.NORMAL
-    gpu = Level.NONE
-    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",
-            advanced=True,
-            uidIgnoreValue="",  # If the invalidation string is empty, it does not participate to the node's UID
-        ),
+
+    # Computable: Characterisics that holds invalidation attribute
+    COMPUTABLE = 1
+
+    # Incomputable: Characterisics that does not need processing
+    INCOMPUTABLE = 2
+
+    # Resizable: Characterisics that allows node's dimensions to be adjusted 
+    RESIZABLE = 3
+
+
+class AttributeFactory:
+
+    # Attribute Defines
+    BASIC = [
         StringParam(
             name="comment",
             label="Comments",
@@ -53,6 +52,72 @@
             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="The Font size for the User Comment.",
+            value=12,
+            range=(6, 100, 1),
+        ),
+        FloatParam(
+            name="nodeWidth",
+            label="Node Width",
+            description="The Node's Width.",
+            value=600,
+            range=None,
+            enabled=False # Hidden always
+        ),
+        FloatParam(
+            name="nodeHeight",
+            label="Node Height",
+            description="The Node's Height.",
+            value=400,
+            range=None,
+            enabled=False # Hidden always
+        ),
+    ]
+
+    @classmethod
+    def getInternalParameters(cls, traits: Traits) -> List[Attribute]:
+        """ Returns an array of Attributes characterized by a given trait.
+        """
+        paramMap = {
+            Traits.COMPUTABLE: cls.INVALIDATION + cls.BASIC,
+            Traits.INCOMPUTABLE: cls.BASIC,
+            Traits.RESIZABLE: cls.BASIC + cls.RESIZABLE
+        }
+
+        return paramMap.get(traits)
+
+
+class Node(object):
+    """
+    """
+    internalFolder = '{cache}/{nodeType}/{uid}/'
+    cpu = Level.NORMAL
+    gpu = Level.NONE
+    ram = Level.NORMAL
+    packageName = ''
+    packageVersion = ''
+
+    internalInputs = AttributeFactory.getInternalParameters(Traits.COMPUTABLE)
+
     inputs = []
     outputs = []
     size = StaticNodeSize(1)
@@ -116,12 +181,18 @@
     """
     Node that does not need to be processed, it is just a placeholder for inputs.
     """
+
+    internalInputs = AttributeFactory.getInternalParameters(Traits.INCOMPUTABLE)
+
     def __init__(self):
         super(InputNode, self).__init__()
 
     def processChunk(self, chunk):
         pass
 
+    def stopProcess(self, chunk):
+        pass
+
 
 class CommandLineNode(Node):
     """

meshroom/core/graph.py

@@ -19,7 +19,7 @@
 from meshroom.core.exception import GraphCompatibilityError, StopGraphVisit, StopBranchVisit
 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 createNode, nodeFactory
 from meshroom.core.typing import PathLike
 
 # Replace default encoder to support Enums
@@ -637,7 +637,7 @@ def addNewNode(self, nodeType, name=None, position=None, **kwargs):
         if name and name in self._nodes.keys():
             name = self._createUniqueNodeName(name)
 
-        n = self.addNode(Node(nodeType, position=position, **kwargs), uniqueName=name)
+        n = self.addNode(createNode(nodeType, position=position, **kwargs), uniqueName=name)
         n.updateInternals()
         return n
 

meshroom/core/node.py

@@ -14,7 +14,7 @@
 import uuid
 from collections import namedtuple
 from enum import Enum
-from typing import Callable, Optional
+from typing import Callable, Optional, Type
 
 import meshroom
 from meshroom.common import Signal, Variant, Property, BaseObject, Slot, ListModel, DictModel
@@ -574,6 +574,42 @@
             return self.internalAttribute("comment").value
         return ""
 
+    def getFontSize(self):
+        """ Gets the Font Size of the node comment.
+
+        Returns:
+            int: The font size from the node if it exists, else 12 as default.
+        """
+        if self.hasInternalAttribute("fontSize"):
+            return self.internalAttribute("fontSize").value
+
+        # Default to 12
+        return 12
+
+    def getNodeWidth(self):
+        """ Gets the Width of the node from the internal attribute.
+
+        Returns:
+            int: The Width from the node if the attribute exists, else 160 as default.
+        """
+        if self.hasInternalAttribute("nodeWidth"):
+            return self.internalAttribute("nodeWidth").value
+
+        # Default to 160
+        return 160
+
+    def getNodeHeight(self):
+        """ Gets the Height of the node from the internal attribute.
+
+        Returns:
+            int: The Height from the node if the attribute exists, else 120 as default.
+        """
+        if self.hasInternalAttribute("nodeHeight"):
+            return self.internalAttribute("nodeHeight").value
+
+        # Default to 120
+        return 120
+
     @Slot(str, result=str)
     def nameToLabel(self, name):
         """
@@ -1200,6 +1236,11 @@
     def _isInputNode(self):
         return isinstance(self.nodeDesc, desc.InputNode)
 
+    def _isBackdropNode(self) -> bool:
+        """ Returns True if the node is a Backdrop type.
+        """
+        return False
+
     @property
     def globalExecMode(self):
         return self._chunks.at(0).execModeName
@@ -1389,6 +1430,11 @@
     color = Property(str, getColor, notify=internalAttributesChanged)
     invalidation = Property(str, getInvalidationMessage, notify=internalAttributesChanged)
     comment = Property(str, getComment, notify=internalAttributesChanged)
+    fontSize = Property(int, getFontSize, notify=internalAttributesChanged)
+
+    # Node Dimensions
+    nodeWidth = Property(float, getNodeWidth, notify=internalAttributesChanged)
+    nodeHeight = Property(float, getNodeHeight, notify=internalAttributesChanged)
     internalFolderChanged = Signal()
     internalFolder = Property(str, internalFolder.fget, notify=internalFolderChanged)
     valuesFile = Property(str, valuesFile.fget, notify=internalFolderChanged)
@@ -1408,6 +1454,7 @@
     # isCompatibilityNode: need lambda to evaluate the virtual function
     isCompatibilityNode = Property(bool, lambda self: self._isCompatibilityNode(), constant=True)
     isInputNode = Property(bool, lambda self: self._isInputNode(), constant=True)
+    isBackdrop = Property(bool, lambda self: self._isBackdropNode(), constant=True)
 
     globalExecModeChanged = Signal()
     globalExecMode = Property(str, globalExecMode.fget, notify=globalExecModeChanged)
@@ -1428,6 +1475,50 @@
     has3DOutput = Property(bool, has3DOutputAttribute, notify=outputAttrEnabledChanged)
 
 
+class Backdrop(BaseNode):
+    """ A Node serving as a Backdrop in the Graph.
+    """
+
+    def __init__(self, nodeType: str, position=None, parent=None, uid=None, **kwargs):
+        super().__init__(nodeType, position, parent=parent, uid=uid, **kwargs)
+
+        if not self.nodeDesc:
+            raise UnknownNodeTypeError(nodeType)
+
+        self.packageName = self.nodeDesc.packageName
+        self.packageVersion = self.nodeDesc.packageVersion
+        self._internalFolder = self.nodeDesc.internalFolder
+
+        for attrDesc in self.nodeDesc.internalInputs:
+            self._internalAttributes.add(attributeFactory(attrDesc, kwargs.get(attrDesc.name, None), isOutput=False,
+                                                          node=self))
+
+    def _isBackdropNode(self) -> bool:
+        """ Returns True.
+        """
+        return True
+
+    def toDict(self) -> dict:
+        """ Returns the serialised data for the Backdrop.
+        """
+        internalInputs = {k: v.getExportValue() for k, v in self._internalAttributes.objects.items()}
+
+        return {
+            'nodeType': self.nodeType,
+            'position': self._position,
+            'parallelization': {
+                'blockSize': 0,
+                'size': 0,
+                'split': 0
+            },
+            'uid': self._uid,
+            'internalFolder': self._internalFolder,
+            'inputs': {},
+            'internalInputs': {k: v for k, v in internalInputs.items() if v is not None},
+            'outputs': {},
+        }
+
+
 class Node(BaseNode):
     """
     A standard Graph node based on a node type.

meshroom/core/nodeFactory.py

@@ -3,7 +3,7 @@
 
 import meshroom.core
 from meshroom.core import Version, desc
-from meshroom.core.node import CompatibilityIssue, CompatibilityNode, Node, Position
+from meshroom.core.node import Backdrop, BaseNode, CompatibilityIssue, CompatibilityNode, Node, Position
 
 
 def nodeFactory(
@@ -29,6 +29,28 @@ def nodeFactory(
     return _NodeCreator(nodeData, name, inTemplate, expectedUid).create()
 
 
+def createNode(nodeType: str, position: Optional[Position]=None, **kwargs) -> BaseNode:
+    """ Create a new Node instance based on given node description.
+        Any other keyword argument will be used to initialize the node's attributes.
+
+    Args:
+        nodeType: Node Plugin/Descriptor name.
+        position: Node Position.
+        parent (BaseObject): this Node's parent.
+        **kwargs: attributes values.
+
+    Returns:
+        The created Node.
+    """
+    constructors = {
+        "Backdrop": Backdrop,
+    }
+    # Node constructor based on NodeType
+    constructor = constructors.get(nodeType, Node)
+
+    return constructor(nodeType, position=position, **kwargs)
+
+
 class _NodeCreator:
 
     def __init__(
@@ -168,7 +190,7 @@ def _checkAttributesCompatibility(
 
     def _createNode(self) -> Node:
         logging.info(f"Creating node '{self.name}'")
-        return Node(
+        return createNode(
             self.nodeType,
             position=self.position,
             uid=self.uid,