WIP interface categories

Author: Fabien Servant

meshroom/core/desc/interface.py

@@ -0,0 +1,35 @@
+class Interface:
+    """Marker base class for node descriptor interfaces.
+
+    Inherit from this to declare a new interface. Classes that inherit from
+    an Interface are automatically discovered by InterfaceMeta and listed in
+    the ``interfaces`` attribute of the concrete node descriptor class.
+    """
+    pass
+
+class InterfaceMeta(type):
+    """Metaclass that populates the ``interfaces`` attribute on any class that uses it.
+
+    When a class is created with this metaclass, ``interfaces`` is set to the list
+    of ``Interface`` subclass names found in the class's MRO (excluding the class
+    itself and the base ``Interface`` marker).
+    """
+    def __new__(mcs, name, bases, namespace):
+        cls = super().__new__(mcs, name, bases, namespace)
+        cls.interfaces = [
+            b.__name__ for b in type.mro(cls)
+            if b is not Interface and b is not cls
+            and isinstance(b, type) and issubclass(b, Interface)
+        ]
+        return cls
+    
+class InterfacedClass(metaclass=InterfaceMeta):
+    """Base class for objects that want automatic interface discovery via InterfaceMeta."""
+    pass
+
+
+class FeatureProviderInterface(Interface):
+
+    def getFeaturesFolders(self, node) -> list:
+        raise NotImplementedError
+

meshroom/core/desc/node.py

@@ -18,6 +18,7 @@
 
 from .computation import Level, StaticNodeSize
 from .attribute import Attribute, ChoiceParam, ColorParam, Flow, IntParam, StringParam, ListAttribute
+from .interface import InterfacedClass
 
 _MESHROOM_COMPUTE = (Path(_MESHROOM_ROOT) / "bin" / "meshroom_compute").as_posix()
 _MESHROOM_COMPUTE_DEPS = ["psutil"]
@@ -212,7 +213,7 @@ def getInternalFlowOutputs(cls, mrNodeType: MrNodeType) -> list[Attribute]:
         return cls.FLOW_OUT
 
 
-class BaseNode(object):
+class BaseNode(InterfacedClass):
     """
     """
     cpu = Level.NORMAL

meshroom/ui/qml/Viewer/Viewer2D.qml

@@ -844,7 +844,7 @@ FocusScope {
                 ExifOrientedViewer {
                     id: featuresViewerLoader
                     active: displayFeatures.checked && !useExternal
-                    property var activeNode: _currentScene ? _currentScene.activeNodes.get("featureProvider").node : null
+                    property var activeNode: _currentScene ? _currentScene.activeNodes.get("FeatureProviderInterface").node : null
                     width: imgContainer.width
                     height: imgContainer.height
                     anchors.centerIn: parent
@@ -1171,7 +1171,7 @@ FocusScope {
                             if (!root.aliceVisionPluginAvailable) {
                                 return null
                             }
-                            return _currentScene ? _currentScene.activeNodes.get("featureProvider").node : null
+                            return _currentScene ? _currentScene.activeNodes.get("FeatureProviderInterface").node : null
                         }
                         property bool isComputed: activeNode && activeNode.isComputed
                         active: isUsed && isComputed
@@ -1187,18 +1187,8 @@ FocusScope {
                                     "featureFolders": Qt.binding(function() {
                                         let result = []
                                         if (activeNode) {
-                                            if (activeNode.nodeType == "FeatureExtraction" && isComputed) {
-                                                result.push(activeNode.attribute("output").value)
-                                            } 
-                                            else if (activeNode.nodeType == "RomaReducer" && isComputed) {
-                                                result.push(activeNode.attribute("featuresFolder").value)
-                                            }
-                                            else if (activeNode.hasAttribute("featuresFolders")) {
-                                                for (let i = 0; i < activeNode.attribute("featuresFolders").value.count; i++) {
-                                                    let attr = activeNode.attribute("featuresFolders").value.at(i)
-                                                    result.push(attr.value)
-                                                }
-                                            }
+                                            result = _currentScene.callInterfaceMethod("FeatureProviderInterface", "getFeaturesFolders")
+                                            console.log(result)
                                         }
                                         return result
                                     }),

meshroom/ui/scene.py

@@ -418,9 +418,15 @@ def initActiveNodes(self):
         # For all nodes declared to be accessed by the UI
         usedNodeTypes = {j for i in self.activeNodeCategories.values() for j in i}
         allLoadedNodeTypes = set(meshroom.core.pluginManager.getRegisteredNodePlugins().keys())
+
+        for nodeType, nodePlugin in meshroom.core.pluginManager.getRegisteredNodePlugins().items():
+            nodeDesc = nodePlugin.nodeDescriptor 
+            for interface in nodeDesc.interfaces:
+                self._activeNodes.add(ActiveNode(interface, parent=self))
+
         allUiNodes = set(self.uiNodes) | usedNodeTypes | allLoadedNodeTypes
 
-        for nodeType in allUiNodes:
+        for nodeType in allUiNodes:            
             self._activeNodes.add(ActiveNode(nodeType, parent=self))
 
     def clearActiveNodes(self):
@@ -985,11 +991,38 @@ def setBuildingIntrinsics(self, value):
 
     pluginsReloaded = Signal(list, list)
 
+    @Slot(str, str, result="QVariant")
+    def callInterfaceMethod(self, interfaceName, methodName):
+        """Call a method defined by an interface on the active node for that interface.
+
+        Args:
+            interfaceName: name of the interface (e.g. "FeatureProviderInterface")
+            methodName: name of the method to call on the nodeDesc (e.g. "getFeaturesFolders")
+
+        Returns:
+            The result of the method call, or None if the interface/method is not available.
+        """
+        entry = self.activeNodes.get(interfaceName)
+        if not entry or not entry.node:
+            return None
+        node = entry.node
+        method = getattr(node.nodeDesc, methodName, None)
+        if callable(method):
+            try:
+                return method(node)
+            except Exception as e:
+                logging.error(f"callInterfaceMethod: {interfaceName}.{methodName} raised: {e}")
+                return None
+        return None
+
     @Slot(QObject)
     def setActiveNode(self, node, categories=True, inputs=True):
         """ Set node as the active node of its type and of its categories.
         Also upgrade related input nodes.
         """
+        for interface in node.nodeDesc.interfaces:
+            self.activeNodes.getr(interface).node = node
+
         if categories:
             for category, nodeTypes in self.activeNodeCategories.items():
                 if node.nodeType in nodeTypes: