Merge pull request #17865 from Ultimaker/CURA-7647-fix-simulation-wit…

…h-multiple-extruders

Case of simulation with multiple extruders

plugins/SimulationView/SimulationPass.py

@@ -1,5 +1,6 @@
 # Copyright (c) 2021 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
+import math
 
 from UM.Math.Color import Color
 from UM.Math.Vector import Vector
@@ -148,24 +149,23 @@ def render(self):
                         if layer == self._layer_view._current_layer_num:
                             # We look for the position of the head, searching the point of the current path
                             index = int(self._layer_view.getCurrentPath())
-                            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
+                                if index >= polygon.data.size // 3 :
+                                    index -= polygon.data.size // 3
                                     continue
                                 # The head position is calculated and translated
-                                ratio = self._layer_view.getCurrentPath() - index
-                                pos_a = Vector(polygon.data[index + offset][0], polygon.data[index + offset][1],
-                                               polygon.data[index + offset][2])
-                                if ratio <= 0.0001 or index + offset < len(polygon.data):
+                                ratio = self._layer_view.getCurrentPath() - math.floor(self._layer_view.getCurrentPath())
+                                pos_a = Vector(polygon.data[index][0], polygon.data[index][1],
+                                               polygon.data[index][2])
+                                if ratio <= 0.0001 or index + 1 == len(polygon.data):
+                                    # in case there multiple polygons and polygon changes, the first point has the same value as the last point in the previous polygon
                                     head_position = pos_a + node.getWorldPosition()
                                 else:
-                                    pos_b = Vector(polygon.data[index + offset + 1][0],
-                                                   polygon.data[index + offset + 1][1],
-                                                   polygon.data[index + offset + 1][2])
+                                    pos_b = Vector(polygon.data[index + 1][0],
+                                                   polygon.data[index + 1][1],
+                                                   polygon.data[index + 1][2])
                                     vec = pos_a * (1.0 - ratio) + pos_b * ratio
                                     head_position = vec + node.getWorldPosition()
                                 break

plugins/SimulationView/SimulationView.py

@@ -57,7 +57,7 @@ class SimulationView(CuraView):
     LAYER_VIEW_TYPE_LINE_TYPE = 1
     LAYER_VIEW_TYPE_FEEDRATE = 2
     LAYER_VIEW_TYPE_THICKNESS = 3
-    SIMULATION_FACTOR = 3
+    SIMULATION_FACTOR = 2
 
     _no_layers_warning_preference = "view/no_layers_warning"
 
@@ -211,7 +211,8 @@ def setTime(self, time: float) -> None:
             left_value = cumulative_line_duration[i - 1] if i > 0 else 0.0
             right_value = cumulative_line_duration[i]
 
-            assert (left_value <= self._current_time <= right_value)
+            if not (left_value <= self._current_time <= right_value):
+                Logger.debug(f"At index {i}: left value {left_value} right value {right_value} and current time is {self._current_time}")
 
             fractional_value = (self._current_time - left_value) / (right_value - left_value)
 
@@ -255,6 +256,8 @@ def cumulativeLineDuration(self) -> List[float]:
                     for line_duration in list((polyline.lineLengths / polyline.lineFeedrates)[0]):
                         total_duration += line_duration / SimulationView.SIMULATION_FACTOR
                         self._cumulative_line_duration[self.getCurrentLayer()].append(total_duration)
+                    # for tool change we add an extra tool path
+                    self._cumulative_line_duration[self.getCurrentLayer()].append(total_duration)
 
         return self._cumulative_line_duration[self.getCurrentLayer()]