wiip

Author: Alxiice

bin/meshroom_compute

@@ -18,6 +18,7 @@ meshroom.setupEnvironment()
 import meshroom.core
 import meshroom.core.graph
 from meshroom.core.node import Status
+from meshroom.core.node import ChunkIndex
 
 
 parser = argparse.ArgumentParser(description='Execute a Graph of processes.')
@@ -49,11 +50,17 @@ parser.add_argument('-v', '--verbose',
                     default=os.environ.get('MESHROOM_VERBOSE', 'info'),
                     choices=['fatal', 'error', 'warning', 'info', 'debug', 'trace'])
 
-parser.add_argument('-i', '--iteration', type=int,
-                    default=-1, help='')
+parser.add_argument('-i', '--iteration', type=int, default=ChunkIndex.NONE, help='')
+parser.add_argument('--preprocess', help='Execute preprocess chunk', action='store_true')
+parser.add_argument('--postprocess', help='Execute postprocess chunk', action='store_true')
 
 args = parser.parse_args()
 
+if args.preprocess:
+    args.iteration = ChunkIndex.PREPROCESS
+elif args.postprocess:
+    args.iteration = ChunkIndex.POSTPROCESS
+
 # Setup the verbose level
 if args.extern:
     # For extern computation, we want to focus on the node computation log.
@@ -111,11 +118,16 @@ if args.node:
         print(f"InputNode: No computation to do.")
         sys.exit(0)
 
+    if args.iteration == ChunkIndex.NONE:
+        chunks = node.chunks
+    elif args.preprocess:
+        chunks = [node._preprocessChunk]
+    elif args.postprocess:
+        chunks = [node._postprocessChunk]
+    else:
+        chunks = [node.chunks[args.iteration]]
+
     if not args.forceStatus and not args.forceCompute:
-        if args.iteration != -1:
-            chunks = [node.chunks[args.iteration]]
-        else:
-            chunks = node.chunks
         for chunk in chunks:
             if chunk.status.status in submittedStatuses:
                 # Particular case for the local isolated, the node status is set to RUNNING by the submitter directly.
@@ -130,23 +142,28 @@ if args.node:
         # Restore the log level
         logging.getLogger().setLevel(meshroom.logStringToPython[args.verbose])
 
+    # Prepare logger
     node.prepareLogger(args.iteration)
-    node.preprocess()
-    if args.iteration != -1:
-        chunk = node.chunks[args.iteration]
-        if chunk._status.status == Status.STOPPED:
-            print(f"Chunk {chunk}: status is STOPPED")
-            killRunningJob(node)
-        chunk.process(args.forceCompute, args.inCurrentEnv)
-    else:
+    # Preprocess
+    node.preprocess(args.forceCompute, args.inCurrentEnv)
+    # Process
+    if args.iteration == ChunkIndex.NONE:
         if node.nodeStatus.status == Status.STOPPED:
             print(f"Node {node}: status is STOPPED")
             killRunningJob(node)
         node.process(args.forceCompute, args.inCurrentEnv)
-    node.postprocess()
+    else:
+        chunk = chunks[0]
+        if chunk._status.status == Status.STOPPED:
+            print(f"Chunk {chunk}: status is STOPPED")
+            killRunningJob(node)
+        chunk.process(args.forceCompute, args.inCurrentEnv)
+    # Postprocess
+    node.postprocess(args.forceCompute, args.inCurrentEnv)
+    # Restore logger
     node.restoreLogger()
 else:
-    if args.iteration != -1:
+    if args.iteration != ChunkIndex.NONE:
         print('Error: "--iteration" only makes sense when used with "--node".')
         sys.exit(-1)
     toNodes = None

meshroom/core/desc/node.py

@@ -422,8 +422,11 @@ def processChunkInEnvironment(self, chunk):
         meshroomComputeCmd = f"{chunk.node.nodeDesc.pythonExecutable} {_MESHROOM_COMPUTE}" + \
                              f" \"{chunk.node.graph.filepath}\" --node {chunk.node.name}" + \
                               " --extern --inCurrentEnv"
-
-        if len(chunk.node.getChunks()) > 1:
+        if chunk.isPreprocess:
+            meshroomComputeCmd += f" --preprocess"
+        elif chunk.isPostprocess:
+            meshroomComputeCmd += f" --postprocess"
+        elif len(chunk.node.getChunks()) > 1:
             meshroomComputeCmd += f" --iteration {chunk.range.iteration}"
 
         runtimeEnv = chunk.node.nodeDesc.plugin.runtimeEnv

meshroom/core/graph.py

@@ -1787,7 +1787,7 @@ def executeGraph(graph, toNodes=None, forceCompute=False, forceStatus=False):
                 continue
 
             print("A")
-            node.preprocess()
+            node.preprocess(forceCompute)
             if not node._chunksCreated:
                 print("B create chunks")
                 node.createChunks()
@@ -1804,7 +1804,7 @@ def executeGraph(graph, toNodes=None, forceCompute=False, forceStatus=False):
                 print("E")
                 chunk.process(forceCompute)
             print("F")
-            node.postprocess()
+            node.postprocess(forceCompute)
         except Exception as exc:
             logging.error(f"Error on node computation: {exc}")
             graph.clearSubmittedNodes()

meshroom/core/node.py

@@ -65,6 +65,7 @@ class ExecMode(Enum):
 
 
 class ChunkIndex(IntEnum):
+    NONE=-3
     PREPROCESS=-2
     POSTPROCESS=-1
     # Standard chunks are indexed from 0
@@ -660,8 +661,6 @@ def isFinished(self):
         return self._status.status == Status.SUCCESS
 
     def process(self, forceCompute=False, inCurrentEnv=False):
-        print(f"(NodeChunk) process {self} -> pre={self.isPreprocess}, post={self.isPostprocess}")
-
         if not forceCompute and self._status.status == Status.SUCCESS:
             logging.info(f"Node chunk already computed: {self.name}")
             return
@@ -670,30 +669,19 @@ def process(self, forceCompute=False, inCurrentEnv=False):
         # This only happens once, when the node has the SUBMITTED status.
         # The sub-process will go through this method again, but the node status will
         # have been set to RUNNING.
-        print(f"(_process) A")
         if not inCurrentEnv and self.node.getMrNodeType() == MrNodeType.NODE:
-            print(f"(_process) B")
             self._processInIsolatedEnvironment()
             return
 
-        print(f"(_process) C")
         runningProcesses[self.name] = self
-        print(f"(_process) D")
         self._status.setNode(self.node)
-        print(f"(_process) E")
         self._status.initStartCompute()
-        print(f"(_process) F")
         self.upgradeStatusFile()
-        print(f"(_process) G")
         executionStatus = None
-        print(f"(_process) H")
         self.statThread = stats.StatisticsThread(self)
-        print(f"(_process) I")
         self.statThread.start()
 
-        print(f"(_process) J")
         try:
-            print(f"(_process) K")
             if self.isPreprocess:
                 self.node.nodeDesc.preprocess(self.node)
             elif self.isPostprocess:
@@ -704,17 +692,14 @@ def process(self, forceCompute=False, inCurrentEnv=False):
             self.node.saveOutputAttr()
             executionStatus = Status.SUCCESS
         except Exception:
-            print(f"(_process) L")
             self.updateStatusFromCache()  # check if the status has been updated by another process
             if self._status.status != Status.STOPPED:
                 executionStatus = Status.ERROR
             raise
         except (KeyboardInterrupt, SystemError, GeneratorExit):
-            print(f"(_process) M")
             executionStatus = Status.STOPPED
             raise
         finally:
-            print(f"(_process) N")
             self._status.setNode(self.node)
             self._status.initEndCompute()
             self.upgradeStatusFile()
@@ -728,8 +713,6 @@ def process(self, forceCompute=False, inCurrentEnv=False):
             self.statistics = stats.Statistics()
             del runningProcesses[self.name]
 
-        print(f"(_process) O")
-
     def _processInIsolatedEnvironment(self):
         """
         Process this node chunk in the isolated environment defined in the environment
@@ -1721,42 +1704,45 @@ def initStatusOnCompute(self, forceCompute=False):
                 chunkPlaceholder._status.status = self._nodeStatus.status
                 self._chunkPlaceholder.setObjectList([chunkPlaceholder])
                 self.chunksChanged.emit()
+    
+    def getChunkName(self, iteration: int):
+        if iteration >= 0:
+            return str(self.chunks[iteration].index)
+        elif iteration == ChunkIndex.PREPROCESS:
+            return "preprocess"
+        elif iteration == ChunkIndex.POSTPROCESS:
+            return "postprocess"
+        return "0"
 
     def processIteration(self, iteration):
         self._chunks[iteration].process()
 
-    def preprocess(self):
+    def preprocess(self, forceCompute=False, inCurrentEnv=False):
         """ Prepare the node processing """
-        print("(preprocess)")
         if self.nodeDesc._hasPreprocess:
-            print("-> has preprocess")
             # self.nodeDesc.preprocess(self)
-            self._preprocessChunk.process()
+            self._preprocessChunk.process(forceCompute, inCurrentEnv)
 
     def process(self, forceCompute=False, inCurrentEnv=False):
-        print("(process)")
         for chunk in self._chunks:
-            print("-> chunk", chunk)
             chunk.process(forceCompute, inCurrentEnv)
 
-    def postprocess(self):
+    def postprocess(self, forceCompute=False, inCurrentEnv=False):
         """
         Invoke the post process on Client Node to execute after the processing on the
         node is completed
         """
-        print("(postprocess)")
         if self.nodeDesc._hasPostprocess:
-            print("-> has postprocess")
             # self.nodeDesc.postprocess(self)
-            self._postprocessChunk.process()
+            self._postprocessChunk.process(forceCompute, inCurrentEnv)
 
     def getLogHandlers(self):
         return self._handlers
 
     def prepareLogger(self, iteration=-1):
         # Get file handler path
-        chunkIndex = self.chunks[iteration].index if iteration != -1 else 0
-        logFileName = f"{chunkIndex}.log"
+        chunkName = self.getChunkName(iteration)
+        logFileName = f"{chunkName}.log"
         logFile = os.path.join(self.internalFolder, logFileName)
         # Setup logger
         rootLogger = logging.getLogger()
@@ -2336,10 +2322,14 @@ def _resetChunks(self):
         """ Set chunks on the node.
         # TODO : Maybe don't delete chunks if we will recreate them as before ?
         """
-        if self.isInputNode:
+        if not self.isComputableType:
             self._chunksCreated = True
             return
         # Disconnect signals
+        if self._preprocessChunk:
+            self._preprocessChunk.statusChanged.disconnect(self.globalStatusChanged)
+        if self._postprocessChunk:
+            self._postprocessChunk.statusChanged.disconnect(self.globalStatusChanged)
         for chunk in self._chunks:
             chunk.statusChanged.disconnect(self.globalStatusChanged)
         # Empty list
@@ -2375,7 +2365,18 @@ def _resetChunks(self):
             self._chunksCreated = False
             self.setSize(0)
             self._chunkPlaceholder.setObjectList([NodeChunk(self, desc.computation.Range())])
-
+        # Pre/post process
+        if self.nodeDesc._hasPreprocess:
+            self._preprocessChunk = NodeChunk(self, desc.Range(ChunkIndex.PREPROCESS))
+            self._preprocessChunk.statusChanged.connect(self.globalStatusChanged)
+        else:
+            self._preprocessChunk = None
+        if self.nodeDesc._hasPostprocess:
+            self._postprocessChunk = NodeChunk(self, desc.Range(ChunkIndex.POSTPROCESS))
+            self._postprocessChunk.statusChanged.connect(self.globalStatusChanged)
+        else:
+            self._postprocessChunk = None
+        
         # Create chunks when possible
         self.chunksCreatedChanged.emit()
         self.chunksChanged.emit()

meshroom/core/taskManager.py

@@ -97,11 +97,8 @@ def run(self):
                 continue
 
 
-            print("(tm) A")
-            node.preprocess()
-            print("(tm) B")
+            node.preprocess(self.forceCompute)
             for cId, chunk in enumerate(node.chunks):
-                print("(tm) C", cId, chunk)
                 if chunk.isFinishedOrRunning() or not self.isRunning():
                     continue
 
@@ -111,17 +108,13 @@ def run(self):
                 _nodeName, _node, _nbNodes = node.nodeType, nId+1, len(self._manager._nodesToProcess)
 
                 if multiChunks:
-                    print("(tm) D0")
                     _chunk, _nbChunks = cId+1, len(node.chunks)
                     logging.info(f"[{_node}/{_nbNodes}]({_chunk}/{_nbChunks}) {_nodeName}")
                 else:
-                    print("(tm) D1")
                     logging.info(f"[{_node}/{_nbNodes}] {_nodeName}")
                 try:
-                    print("(tm) D")
                     chunk.process(self.forceCompute)
                 except Exception as exc:
-                    print("(tm) D2")
                     if chunk.isStopped():
                         stopAndRestart = True
                         break
@@ -136,8 +129,7 @@ def run(self):
                                 # Node already removed (for instance a global clear of _nodesToProcess)
                                 pass
                             n.clearSubmittedChunks()
-            print("(tm) E")
-            node.postprocess()
+            node.postprocess(self.forceCompute)
 
             if stopAndRestart:
                 break

meshroom/ui/qml/GraphEditor/ChunksListView.qml

@@ -22,7 +22,6 @@ ColumnLayout {
     property int currentIndex: 0
 
     function getCurrentChunkIndex() {
-        console.log("(getCurrentChunkIndex)", currentIndex, chunks.length)
         if ( currentIndex == undefined || !chunks || currentIndex == ChunksListView.IndexItems.NULL ) { return -1 }
         let hasPreprocess  = chunks.some(function(chk) { return chk.chunkIndex == ChunksListView.IndexItems.PREPROCESS })
         let hasPostprocess = chunks.some(function(chk) { return chk.chunkIndex == ChunksListView.IndexItems.POSTPROCESS })
@@ -33,7 +32,7 @@ ColumnLayout {
 
     property int currentItemIndex: getCurrentChunkIndex()
 
-    property variant currentChunk: (currentItemIndex >= 0 && chunks && chunks.length > currentItemIndex) ? chunks[currentItemIndex].chunk : null
+    property variant currentChunk: (currentItemIndex >= 0 && chunks && chunks.length > currentItemIndex) ? chunks[currentItemIndex].chunk : undefined
 
     onChunksChanged: {
         // When the list changes, ensure the current index is in the new range
@@ -95,7 +94,6 @@ ColumnLayout {
             width: ListView.view.width
             leftPadding: 8
             onClicked: {
-                console.log("clicked on chunk", chunkIndex, "(", text, ")")
                 chunksLV.forceActiveFocus()
                 root.currentIndex = chunkIndex
             }

meshroom/ui/qml/GraphEditor/NodeLog.qml

@@ -17,10 +17,6 @@ FocusScope {
     property int currentChunkIndex
     property variant currentChunk
 
-    onCurrentChunkIndexChanged: {
-        console.log("[log] changed chunk :", currentChunkIndex, root.currentChunk.logFile)
-    }
-
     Layout.fillWidth: true
     Layout.fillHeight: true