Revert speedup

2 files changed, 24 insertions, 42 deletions

diff --git a/plugins/SimulationView/SimulationPass.py b/plugins/SimulationView/SimulationPass.py
index 216424b890..24bdedd368 100644
--- a/plugins/SimulationView/SimulationPass.py
+++ b/plugins/SimulationView/SimulationPass.py
@@ -112,24 +112,29 @@ class SimulationPass(RenderPass):
 
                 # Render all layers below a certain number as line mesh instead of vertices.
                 if self._layer_view._current_layer_num > -1 and ((not self._layer_view._only_show_top_layers) or (not self._layer_view.getCompatibilityMode())):
-                    start = self._layer_view.start_elements_index
-                    end = self._layer_view.end_elements_index
-                    index = self._layer_view._current_path_num
-                    offset = 0
-                    layer = layer_data.getLayer(self._layer_view._current_layer_num)
-                    if layer is None:
-                        continue
-                    for polygon in layer.polygons:
-                        # The size indicates all values in the two-dimension array, and the second dimension is
-                        # always size 3 because we have 3D points.
-                        if index >= polygon.data.size // 3 - offset:
-                            index -= polygon.data.size // 3 - offset
-                            offset = 1  # This is to avoid the first point when there is more than one polygon, since has the same value as the last point in the previous polygon
-                            continue
-                        # The head position is calculated and translated
-                        head_position = Vector(polygon.data[index + offset][0], polygon.data[index + offset][1],
-                                               polygon.data[index + offset][2]) + node.getWorldPosition()
-                        break
+                    start = 0
+                    end = 0
+                    element_counts = layer_data.getElementCounts()
+                    for layer in sorted(element_counts.keys()):
+                        # In the current layer, we show just the indicated paths
+                        if layer == self._layer_view._current_layer_num:
+                            # We look for the position of the head, searching the point of the current path
+                            index = self._layer_view._current_path_num
+                            offset = 0
+                            for polygon in layer_data.getLayer(layer).polygons:
+                                # The size indicates all values in the two-dimension array, and the second dimension is
+                                # always size 3 because we have 3D points.
+                                if index >= polygon.data.size // 3 - offset:
+                                    index -= polygon.data.size // 3 - offset
+                                    offset = 1  # This is to avoid the first point when there is more than one polygon, since has the same value as the last point in the previous polygon
+                                    continue
+                                # The head position is calculated and translated
+                                head_position = Vector(polygon.data[index+offset][0], polygon.data[index+offset][1], polygon.data[index+offset][2]) + node.getWorldPosition()
+                                break
+                            break
+                        if self._layer_view._minimum_layer_num > layer:
+                            start += element_counts[layer]
+                        end += element_counts[layer]
 
                     # Calculate the range of paths in the last layer
                     current_layer_start = end
diff --git a/plugins/SimulationView/SimulationView.py b/plugins/SimulationView/SimulationView.py
index 98eda48477..e44c2c180a 100644
--- a/plugins/SimulationView/SimulationView.py
+++ b/plugins/SimulationView/SimulationView.py
@@ -71,8 +71,6 @@ class SimulationView(CuraView):
         self._max_paths = 0
         self._current_path_num = 0
         self._minimum_path_num = 0
-        self.start_elements_index = 0
-        self.end_elements_index = 0
         self.currentLayerNumChanged.connect(self._onCurrentLayerNumChanged)
 
         self._busy = False
@@ -247,7 +245,6 @@ class SimulationView(CuraView):
                 self._minimum_layer_num = self._current_layer_num
 
             self._startUpdateTopLayers()
-            self.recalculateStartEndElements()
 
             self.currentLayerNumChanged.emit()
 
@@ -262,7 +259,7 @@ class SimulationView(CuraView):
                 self._current_layer_num = self._minimum_layer_num
 
             self._startUpdateTopLayers()
-            self.recalculateStartEndElements()
+
             self.currentLayerNumChanged.emit()
 
     def setPath(self, value: int) -> None:
@@ -276,7 +273,6 @@ class SimulationView(CuraView):
                 self._minimum_path_num = self._current_path_num
 
             self._startUpdateTopLayers()
-            self.recalculateStartEndElements()
             self.currentPathNumChanged.emit()
 
     def setMinimumPath(self, value: int) -> None:
@@ -364,24 +360,6 @@ class SimulationView(CuraView):
             return 0.0 # If it's still max-float, there are no measurements. Use 0 then.
         return self._min_thickness
 
-    def recalculateStartEndElements(self):
-        self.start_elements_index = 0
-        self.end_elements_index = 0
-        scene = self.getController().getScene()
-        for node in DepthFirstIterator(scene.getRoot()):  # type: ignore
-            layer_data = node.callDecoration("getLayerData")
-            if not layer_data:
-                continue
-
-            # Found a the layer data!
-            element_counts = layer_data.getElementCounts()
-            for layer in sorted(element_counts.keys()):
-                if layer == self._current_layer_num:
-                    break
-                if self._minimum_layer_num > layer:
-                    self.start_elements_index += element_counts[layer]
-                self.end_elements_index += element_counts[layer]
-
     def getMaxThickness(self) -> float:
         return self._max_thickness
 
@@ -603,7 +581,6 @@ class SimulationView(CuraView):
     def _startUpdateTopLayers(self) -> None:
         if not self._compatibility_mode:
             return
-        self.recalculateStartEndElements()
         if self._top_layers_job:
             self._top_layers_job.finished.disconnect(self._updateCurrentLayerMesh)
             self._top_layers_job.cancel()