From 8d13cfb5d626f5b31efd28bfb53a8bc0534ab062 Mon Sep 17 00:00:00 2001 From: Ghostkeeper Date: Sat, 3 Apr 2021 16:03:20 +0200 Subject: [PATCH] Make limits in colour scheme depend on the visible line types This way, if travel moves are not currently visible in the layer view, the travel moves don't get counted with the limits to determine the colour spectrum to grade each line with. Quite often, travel moves had a much greater speed than other moves, like 120mm/s instead of the fastest printed line 60mm/s. This caused all of the layer view to be pushed into the lower end of the spectrum. It makes it hard to distinguish the differences in speed and line width because travel moves influence the spectrum so much. This way, the travel moves only influence the spectrum if they are visible. If they are visible, it might be relevant to the user. Otherwise, the user gets the full spectrum to differentiate between all the line widths and speeds. This currently doesn't update correctly yet. That is something we'll need to fix. --- plugins/SimulationView/SimulationView.py | 43 +++++++++++++++++++----- 1 file changed, 35 insertions(+), 8 deletions(-) diff --git a/plugins/SimulationView/SimulationView.py b/plugins/SimulationView/SimulationView.py index 9494e42a5e..1cf7a26768 100644 --- a/plugins/SimulationView/SimulationView.py +++ b/plugins/SimulationView/SimulationView.py @@ -1,4 +1,4 @@ -# Copyright (c) 2020 Ultimaker B.V. +# Copyright (c) 2021 Ultimaker B.V. # Cura is released under the terms of the LGPLv3 or higher. import sys @@ -30,6 +30,7 @@ from UM.View.GL.ShaderProgram import ShaderProgram from UM.i18n import i18nCatalog from cura.CuraView import CuraView +from cura.LayerPolygon import LayerPolygon # To distinguish line types. from cura.Scene.ConvexHullNode import ConvexHullNode from cura.CuraApplication import CuraApplication @@ -399,11 +400,32 @@ class SimulationView(CuraView): return self._min_line_width def calculateMaxLayers(self) -> None: + """ + Calculates number of layers, and the limits of each statistic for the colour schemes. + """ scene = self.getController().getScene() + visible_line_types = [] + if self.getShowSkin(): # Actually "shell". + visible_line_types.append(LayerPolygon.SkinType) + visible_line_types.append(LayerPolygon.Inset0Type) + visible_line_types.append(LayerPolygon.InsetXType) + if self.getShowStarts(): + visible_line_types.append(LayerPolygon.NoneType) + if self.getShowInfill(): + visible_line_types.append(LayerPolygon.InfillType) + if self.getShowHelpers(): + visible_line_types.append(LayerPolygon.PrimeTowerType) + visible_line_types.append(LayerPolygon.SkirtType) + visible_line_types.append(LayerPolygon.SupportType) + visible_line_types.append(LayerPolygon.SupportInfillType) + visible_line_types.append(LayerPolygon.SupportInterfaceType) + if self.getShowTravelMoves(): + visible_line_types.append(LayerPolygon.MoveCombingType) + visible_line_types.append(LayerPolygon.MoveRetractionType) + self._old_max_layers = self._max_layers new_max_layers = -1 - """Recalculate num max layers""" for node in DepthFirstIterator(scene.getRoot()): # type: ignore layer_data = node.callDecoration("getLayerData") if not layer_data: @@ -420,13 +442,18 @@ class SimulationView(CuraView): # Store the max and min feedrates and thicknesses for display purposes for p in layer_data.getLayer(layer_id).polygons: - self._max_feedrate = max(float(p.lineFeedrates.max()), self._max_feedrate) - self._min_feedrate = min(float(p.lineFeedrates.min()), self._min_feedrate) - self._max_line_width = max(float(p.lineWidths.max()), self._max_line_width) - self._min_line_width = min(float(p.lineWidths.min()), self._min_line_width) - self._max_thickness = max(float(p.lineThicknesses.max()), self._max_thickness) + is_visible = numpy.isin(p.types, visible_line_types) + visible_indices = numpy.where(is_visible) + visible_feedrates = numpy.take(p.lineFeedrates, visible_indices) + visible_linewidths = numpy.take(p.lineWidths, visible_indices) + visible_thicknesses = numpy.take(p.lineThicknesses, visible_indices) + self._max_feedrate = max(float(visible_feedrates.max()), self._max_feedrate) + self._min_feedrate = min(float(visible_feedrates.min()), self._min_feedrate) + self._max_line_width = max(float(visible_linewidths.max()), self._max_line_width) + self._min_line_width = min(float(visible_linewidths.min()), self._min_line_width) + self._max_thickness = max(float(visible_thicknesses.max()), self._max_thickness) try: - self._min_thickness = min(float(p.lineThicknesses[numpy.nonzero(p.lineThicknesses)].min()), self._min_thickness) + self._min_thickness = min(float(visible_thicknesses[numpy.nonzero(visible_thicknesses)].min()), self._min_thickness) except ValueError: # Sometimes, when importing a GCode the line thicknesses are zero and so the minimum (avoiding # the zero) can't be calculated