Rearrange force directed layouts to use the undo redo stack.

Author: hsorby

src/mapclient/core/managers/workflowmanager.py

@@ -25,8 +25,6 @@
 from PySide6 import QtCore
 
 from mapclient.core.metrics import metrics_logger
-from mapclient.core.workflow.layouts.forcedirected import ForceDirectedLayout
-from mapclient.core.workflow.layouts.springforce import SpringForce
 from mapclient.settings import info
 from mapclient.core.workflow.workflowscene import WorkflowScene, read_steps, load_from
 from mapclient.core.workflow.workflowsteps import WorkflowSteps, \
@@ -61,20 +59,6 @@ def _get_workflow_meta_absolute_filename(location):
     return os.path.join(location, info.DEFAULT_WORKFLOW_ANNOTATION_FILENAME)
 
 
-def _determine_input_output_ports(meta_step):
-    """
-    Determine the input and output ports for a step.
-    :param meta_step: The step to determine the ports for.
-    :return: A list of input and output ports.
-    """
-    step = meta_step.getStep()
-    step_ports = step.getPorts()
-    uses_ports = [port for port in step_ports if port.has_uses()]
-    provides_ports = [port for port in step_ports if port.has_provides()]
-
-    return {'inputs': len(uses_ports), 'outputs': len(provides_ports)}
-
-
 class WorkflowManager(object):
     """
     This class manages (models?) the workflow.
@@ -88,10 +72,6 @@ def __init__(self, parent):
         self._previousLocation = None
         self._saveStateIndex = 0
         self._currentStateIndex = 0
-        self._layout_engine = None
-        self._layout_timer = QtCore.QTimer()
-        self._layout_timer.timeout.connect(self._animation_step)
-        self._iteration_count = 0
 
         self._title = None
 
@@ -158,97 +138,6 @@ def abort_execution(self):
     def set_workflow_direction(self, direction):
         self._scene.set_workflow_direction(direction)
 
-    def layout_workflow(self, layout_algorithm, animate=True):
-        graph, graph_edges, reverse_graph = self._scene.graph()
-        view_parameters = self._scene.getViewParameters()
-        adjacent_graph = {}
-        vertices = []
-
-        unique_meta_steps = set()
-        for node, targets in graph.items():
-            unique_meta_steps.add(node)
-            unique_meta_steps.update(targets)
-
-            vertices.append(node)
-            adjacent_graph[node] = graph[node]
-
-        node_definitions = {}
-        for node in unique_meta_steps:
-            node_ports = _determine_input_output_ports(node)
-            node_definitions[node.getIdentifier()] = {
-                'name': node.getName(),
-                'position': (node.getPos().x(), node.getPos().y()),
-                'inputs': node_ports['inputs'],
-                'outputs': node_ports['outputs'],
-            }
-
-        edge_definitions = [
-            {'from': edge['from'].getIdentifier(), 'from_port': edge['from_port'],
-             'to': edge['to'].getIdentifier(), 'to_port': edge['to_port']}
-            for edge in graph_edges
-        ]
-
-        for node in reverse_graph:
-            if node not in adjacent_graph:
-                vertices.append(node)
-                adjacent_graph[node] = []
-
-            adjacent_graph[node] = list(set(adjacent_graph[node] + reverse_graph[node]))
-
-        all_set = set(adjacent_graph.keys())
-        non_adjacent_graph = {}
-        for node in adjacent_graph:
-            adjacent_set = set(adjacent_graph[node])
-            non_adjacent_set = all_set - adjacent_set - {node}
-            non_adjacent_graph[node] = list(non_adjacent_set)
-
-        dataset = {
-            'vertices': vertices,
-            'adjacent': adjacent_graph,
-            'non_adjacent': non_adjacent_graph
-        }
-
-        if layout_algorithm == 'force_directed':
-            self._layout_engine = ForceDirectedLayout(node_definitions, edge_definitions, view_parameters['rect'].width())
-        elif layout_algorithm == 'spring_force':
-            self._layout_engine = SpringForce(dataset, iterations=100, target_node_speed=0.01)
-        else:
-            raise WorkflowError(f"Unknown layout algorithm: {layout_algorithm}")
-
-        self._iteration_count = 0
-        if animate:
-            self._layout_timer.start(16)
-        else:
-            self._layout_worfklow()
-
-    def _layout_worfklow(self):
-        while self._iteration_count < self._layout_engine.max_iterations():
-            if hasattr(self._layout_engine, 'update_layout'):
-                damping = 1.0 - (self._iteration_count / self._layout_engine.max_iterations())
-                self._layout_engine.update_layout(damping)
-            elif hasattr(self._layout_engine, 'spring_layout'):
-                self._layout_engine.spring_layout(c1=2.0, c2=10.0, c3=1000000, c4=1, return_after=1)
-
-            self._iteration_count += 1
-
-        positions = {k: QtCore.QPoint(v[0], v[1]) for k, v in self._layout_engine.positions().items()}
-        self._scene.set_step_positions(positions)
-
-    def _animation_step(self):
-        if self._iteration_count >= self._layout_engine.max_iterations():
-            self._layout_timer.stop()
-            return
-
-        if hasattr(self._layout_engine, 'update_layout'):
-            damping = 1.0 - (self._iteration_count / self._layout_engine.max_iterations())
-            self._layout_engine.update_layout(damping)
-        elif hasattr(self._layout_engine, 'spring_layout'):
-            self._layout_engine.spring_layout(c1=2.0, c2=10.0, c3=1000000, c4=1, return_after=1)
-
-        positions = {k: QtCore.QPoint(v[0], v[1]) for k, v in self._layout_engine.positions().items()}
-        self._scene.set_step_positions(positions)
-        self._iteration_count += 1
-
     def canExecute(self):
         return self._scene.canExecute()
 

src/mapclient/view/workflow/workflowgraphicsview.py

@@ -22,6 +22,8 @@
 
 from PySide6 import QtCore, QtWidgets, QtGui
 
+from mapclient.core.workflow.layouts.forcedirected import ForceDirectedLayout
+from mapclient.core.workflow.layouts.springforce import SpringForce
 from mapclient.core.workflow.workflowutils import revert_parameterised_position
 from mapclient.mountpoints.workflowstep import workflowStepFactory
 from mapclient.core.workflow.workflowscene import MetaStep
@@ -31,6 +33,12 @@
 
 logger = logging.getLogger()
 
+# This is the threshold for the stability of the layout. If the change in position of all nodes is less than this value,
+# the layout is considered stable and the animation stops.
+STABILITY_THRESHOLD = 0.05
+# The number of consecutive stable frames before the layout is considered stable.
+CONSECUTIVE_STABLE_FRAMES = 5
+
 
 class WorkflowGraphicsView(QtWidgets.QGraphicsView):
 
@@ -48,6 +56,14 @@ def __init__(self, parent=None):
         self._graphics_scale_factor = 1.0
         self._margin = 10
 
+        self._layout_engine = None
+        self._layout_timer = QtCore.QTimer()
+        self._layout_timer.timeout.connect(self._animation_step)
+        self._layout_iteration_count = 0
+        self._layout_initial_positions = None
+        self._layout_previous_positions = None
+        self._layout_stability_counter = 0
+
         self._undoStack = None
         self._location = ''
         self._showStepNames = True
@@ -602,3 +618,150 @@ def scale_workflow(self, sf_x, sf_y):
                 if x != item.x() or y != item.y():
                     self._undoStack.push(CommandMove(item, item.pos(), QtCore.QPointF(x, y)))
         self._undoStack.endMacro()
+
+    def layout_workflow(self, layout_algorithm, animate=True):
+        sceneRect = self.sceneRect()
+        core_scene = self.scene().workflowScene()
+
+        graph, graph_edges, reverse_graph = core_scene.graph()
+        adjacent_graph = {}
+        vertices = []
+
+        unique_meta_steps = set()
+        for node, targets in graph.items():
+            unique_meta_steps.add(node)
+            unique_meta_steps.update(targets)
+
+            vertices.append(node)
+            adjacent_graph[node] = graph[node]
+
+        node_definitions = {}
+        for node in unique_meta_steps:
+            node_ports = _determine_input_output_ports(node)
+            node_definitions[node.getIdentifier()] = {
+                'name': node.getName(),
+                'position': (node.getPos().x(), node.getPos().y()),
+                'inputs': node_ports['inputs'],
+                'outputs': node_ports['outputs'],
+            }
+
+        edge_definitions = [
+            {'from': edge['from'].getIdentifier(), 'from_port': edge['from_port'],
+             'to': edge['to'].getIdentifier(), 'to_port': edge['to_port']}
+            for edge in graph_edges
+        ]
+
+        for node in reverse_graph:
+            if node not in adjacent_graph:
+                vertices.append(node)
+                adjacent_graph[node] = []
+
+            adjacent_graph[node] = list(set(adjacent_graph[node] + reverse_graph[node]))
+
+        all_set = set(adjacent_graph.keys())
+        non_adjacent_graph = {}
+        for node in adjacent_graph:
+            adjacent_set = set(adjacent_graph[node])
+            non_adjacent_set = all_set - adjacent_set - {node}
+            non_adjacent_graph[node] = list(non_adjacent_set)
+
+        dataset = {
+            'vertices': vertices,
+            'adjacent': adjacent_graph,
+            'non_adjacent': non_adjacent_graph
+        }
+
+        if layout_algorithm == 'force_directed':
+            self._layout_engine = ForceDirectedLayout(node_definitions, edge_definitions, sceneRect.width())
+        elif layout_algorithm == 'spring_force':
+            self._layout_engine = SpringForce(dataset, iterations=100, target_node_speed=0.01)
+
+        self._layout_iteration_count = 0
+        self._layout_initial_positions = {k: QtCore.QPoint(v[0], v[1]) for k, v in self._layout_engine.positions().items()}
+        self._layout_previous_positions = {k: QtCore.QPoint(v[0], v[1]) for k, v in self._layout_engine.positions().items()}
+        if animate:
+            self._undoStack.beginMacro('Move Step(s)')
+            self._layout_timer.start(16)
+        else:
+            self._layout_workflow()
+
+    def _move_nodes(self, positions):
+        for item in self.items():
+            if item.type() == Node.Type:
+                item_identifier = item.metaItem().getIdentifier()
+                if item_identifier in positions:
+                    self._undoStack.push(CommandMove(item, self._layout_initial_positions[item_identifier], positions[item_identifier]))
+
+    def _layout_workflow(self):
+        while self._layout_iteration_count < self._layout_engine.max_iterations():
+            if hasattr(self._layout_engine, 'update_layout'):
+                damping = 1.0 - (self._layout_iteration_count / self._layout_engine.max_iterations())
+                self._layout_engine.update_layout(damping)
+            elif hasattr(self._layout_engine, 'spring_layout'):
+                self._layout_engine.spring_layout(c1=2.0, c2=10.0, c3=1000000, c4=1, return_after=1)
+
+            positions = {k: QtCore.QPoint(v[0], v[1]) for k, v in self._layout_engine.positions().items()}
+            self._check_stability(positions)
+
+            self._layout_iteration_count += 1
+
+        positions = {k: QtCore.QPoint(v[0], v[1]) for k, v in self._layout_engine.positions().items()}
+
+        self._undoStack.beginMacro('Move Step(s)')
+        self._move_nodes(positions)
+        self._undoStack.endMacro()
+
+    def _check_stability(self, positions):
+        total_movement_sq = _calculate_total_movement(self._layout_previous_positions, positions)
+        self._layout_previous_positions = positions
+        if total_movement_sq < STABILITY_THRESHOLD:
+            self._layout_stability_counter += 1
+        else:
+            # If there's any significant movement, reset the counter
+            self._layout_stability_counter = 0
+
+        if self._layout_stability_counter >= CONSECUTIVE_STABLE_FRAMES:
+            self._layout_iteration_count = self._layout_engine.max_iterations()
+
+    def _animation_step(self):
+        if self._layout_iteration_count >= self._layout_engine.max_iterations():
+            self._undoStack.endMacro()
+            self._layout_timer.stop()
+            return
+
+        if hasattr(self._layout_engine, 'update_layout'):
+            damping = 1.0 - (self._layout_iteration_count / self._layout_engine.max_iterations())
+            self._layout_engine.update_layout(damping)
+        elif hasattr(self._layout_engine, 'spring_layout'):
+            self._layout_engine.spring_layout(c1=2.0, c2=10.0, c3=1000000, c4=1, return_after=1)
+
+        positions = {k: QtCore.QPoint(v[0], v[1]) for k, v in self._layout_engine.positions().items()}
+        self._move_nodes(positions)
+        self._check_stability(positions)
+        self._layout_iteration_count += 1
+
+
+def _calculate_total_movement(previous_positions, current_positions):
+    total_movement_sq = 0
+    for identifier, prev_pos in previous_positions.items():
+        curr_pos = current_positions[identifier]
+
+        dx = curr_pos.x() - prev_pos.x()
+        dy = curr_pos.y() - prev_pos.y()
+        total_movement_sq += dx * dx + dy * dy
+
+    return total_movement_sq
+
+
+def _determine_input_output_ports(meta_step):
+    """
+    Determine the input and output ports for a step.
+    :param meta_step: The step to determine the ports for.
+    :return: A list of input and output ports.
+    """
+    step = meta_step.getStep()
+    step_ports = step.getPorts()
+    uses_ports = [port for port in step_ports if port.has_uses()]
+    provides_ports = [port for port in step_ports if port.has_provides()]
+
+    return {'inputs': len(uses_ports), 'outputs': len(provides_ports)}

src/mapclient/view/workflow/workflowwidget.py

@@ -210,7 +210,7 @@ def _abort_workflow(self):
         self._reset_workflow_direction()
 
     def _do_layout(self, layout_type):
-        self._workflowManager.layout_workflow(layout_type, self._options_manager.getOption(ANIMATE_LAYOUT_UPDATES))
+        self._ui.graphicsView.layout_workflow(layout_type, self._options_manager.getOption(ANIMATE_LAYOUT_UPDATES))
 
     def _spring_force_layout(self):
         self._do_layout("spring_force")