def _convertSavitarNodeToUMNode(
self,
savitar_node: Savitar.SceneNode,
file_name: str = "") -> Optional[SceneNode]:
"""Convenience function that converts a SceneNode object (as obtained from libSavitar) to a scene node.
:returns: Scene node.
"""
try:
node_name = savitar_node.getName()
node_id = savitar_node.getId()
except AttributeError:
Logger.log(
"e",
"Outdated version of libSavitar detected! Please update to the newest version!"
)
node_name = ""
node_id = ""
if node_name == "":
if file_name != "":
node_name = os.path.basename(file_name)
else:
node_name = "Object {}".format(node_id)
active_build_plate = CuraApplication.getInstance(
).getMultiBuildPlateModel().activeBuildPlate
um_node = CuraSceneNode() # This adds a SettingOverrideDecorator
um_node.addDecorator(BuildPlateDecorator(active_build_plate))
try:
um_node.addDecorator(ConvexHullDecorator())
except:
pass
um_node.setName(node_name)
um_node.setId(node_id)
transformation = self._createMatrixFromTransformationString(
savitar_node.getTransformation())
um_node.setTransformation(transformation)
mesh_builder = MeshBuilder()
data = numpy.fromstring(
savitar_node.getMeshData().getFlatVerticesAsBytes(),
dtype=numpy.float32)
vertices = numpy.resize(data, (int(data.size / 3), 3))
mesh_builder.setVertices(vertices)
mesh_builder.calculateNormals(fast=True)
if file_name:
# The filename is used to give the user the option to reload the file if it is changed on disk
# It is only set for the root node of the 3mf file
mesh_builder.setFileName(file_name)
mesh_data = mesh_builder.build()
if len(mesh_data.getVertices()):
um_node.setMeshData(mesh_data)
for child in savitar_node.getChildren():
child_node = self._convertSavitarNodeToUMNode(child)
if child_node:
um_node.addChild(child_node)
if um_node.getMeshData() is None and len(um_node.getChildren()) == 0:
return None
settings = savitar_node.getSettings()
# Add the setting override decorator, so we can add settings to this node.
if settings:
global_container_stack = CuraApplication.getInstance(
).getGlobalContainerStack()
# Ensure the correct next container for the SettingOverride decorator is set.
if global_container_stack:
default_stack = ExtruderManager.getInstance().getExtruderStack(
0)
if default_stack:
um_node.callDecoration("setActiveExtruder",
default_stack.getId())
# Get the definition & set it
definition_id = ContainerTree.getInstance().machines[
global_container_stack.definition.getId(
)].quality_definition
um_node.callDecoration("getStack").getTop().setDefinition(
definition_id)
setting_container = um_node.callDecoration("getStack").getTop()
known_setting_keys = um_node.callDecoration(
"getStack").getAllKeys()
for key in settings:
setting_value = settings[key].value
# Extruder_nr is a special case.
if key == "extruder_nr":
extruder_stack = ExtruderManager.getInstance(
).getExtruderStack(int(setting_value))
if extruder_stack:
um_node.callDecoration("setActiveExtruder",
extruder_stack.getId())
else:
Logger.log("w",
"Unable to find extruder in position %s",
setting_value)
continue
if key in known_setting_keys:
setting_container.setProperty(key, "value", setting_value)
else:
um_node.metadata[key] = settings[key]
if len(um_node.getChildren()) > 0 and um_node.getMeshData() is None:
if len(um_node.getAllChildren()) == 1:
# We don't want groups of one, so move the node up one "level"
child_node = um_node.getChildren()[0]
parent_transformation = um_node.getLocalTransformation()
child_transformation = child_node.getLocalTransformation()
child_node.setTransformation(
parent_transformation.multiply(child_transformation))
um_node = cast(CuraSceneNode, um_node.getChildren()[0])
else:
group_decorator = GroupDecorator()
um_node.addDecorator(group_decorator)
um_node.setSelectable(True)
if um_node.getMeshData():
# Assuming that all nodes with mesh data are printable objects
# affects (auto) slicing
sliceable_decorator = SliceableObjectDecorator()
um_node.addDecorator(sliceable_decorator)
return um_node
def run(self):
Logger.log(
"d", "Processing new layer for build plate %s..." %
self._build_plate_number)
start_time = time()
view = Application.getInstance().getController().getActiveView()
if view.getPluginId() == "SimulationView":
view.resetLayerData()
self._progress_message.show()
Job.yieldThread()
if self._abort_requested:
if self._progress_message:
self._progress_message.hide()
return
Application.getInstance().getController().activeViewChanged.connect(
self._onActiveViewChanged)
# The no_setting_override is here because adding the SettingOverrideDecorator will trigger a reslice
new_node = CuraSceneNode(no_setting_override=True)
new_node.addDecorator(BuildPlateDecorator(self._build_plate_number))
# Force garbage collection.
# For some reason, Python has a tendency to keep the layer data
# in memory longer than needed. Forcing the GC to run here makes
# sure any old layer data is really cleaned up before adding new.
gc.collect()
mesh = MeshData()
layer_data = LayerDataBuilder.LayerDataBuilder()
layer_count = len(self._layers)
# Find the minimum layer number
# When disabling the remove empty first layers setting, the minimum layer number will be a positive
# value. In that case the first empty layers will be discarded and start processing layers from the
# first layer with data.
# When using a raft, the raft layers are sent as layers < 0. Instead of allowing layers < 0, we
# simply offset all other layers so the lowest layer is always 0. It could happens that the first
# raft layer has value -8 but there are just 4 raft (negative) layers.
min_layer_number = sys.maxsize
negative_layers = 0
for layer in self._layers:
if layer.repeatedMessageCount("path_segment") > 0:
if layer.id < min_layer_number:
min_layer_number = layer.id
if layer.id < 0:
negative_layers += 1
### START PATCH
global_container_stack = Application.getInstance(
).getGlobalContainerStack()
half_outer_wall_thickness = global_container_stack.getProperty(
"wall_line_width_0", "value") / 2
### END PATCH
current_layer = 0
for layer in self._layers:
# If the layer is below the minimum, it means that there is no data, so that we don't create a layer
# data. However, if there are empty layers in between, we compute them.
if layer.id < min_layer_number:
continue
# Layers are offset by the minimum layer number. In case the raft (negative layers) is being used,
# then the absolute layer number is adjusted by removing the empty layers that can be in between raft
# and the model
abs_layer_number = layer.id - min_layer_number
if layer.id >= 0 and negative_layers != 0:
abs_layer_number += (min_layer_number + negative_layers)
layer_data.addLayer(abs_layer_number)
this_layer = layer_data.getLayer(abs_layer_number)
layer_data.setLayerHeight(abs_layer_number, layer.height)
layer_data.setLayerThickness(abs_layer_number, layer.thickness)
for p in range(layer.repeatedMessageCount("path_segment")):
polygon = layer.getRepeatedMessage("path_segment", p)
extruder = polygon.extruder
line_types = numpy.fromstring(
polygon.line_type,
dtype="u1") # Convert bytearray to numpy array
line_types = line_types.reshape((-1, 1))
points = numpy.fromstring(
polygon.points,
dtype="f4") # Convert bytearray to numpy array
if polygon.point_type == 0: # Point2D
points = points.reshape(
(-1, 2)
) # We get a linear list of pairs that make up the points, so make numpy interpret them correctly.
else: # Point3D
points = points.reshape((-1, 3))
line_widths = numpy.fromstring(
polygon.line_width,
dtype="f4") # Convert bytearray to numpy array
line_widths = line_widths.reshape(
(-1, 1)
) # We get a linear list of pairs that make up the points, so make numpy interpret them correctly.
line_thicknesses = numpy.fromstring(
polygon.line_thickness,
dtype="f4") # Convert bytearray to numpy array
line_thicknesses = line_thicknesses.reshape(
(-1, 1)
) # We get a linear list of pairs that make up the points, so make numpy interpret them correctly.
line_feedrates = numpy.fromstring(
polygon.line_feedrate,
dtype="f4") # Convert bytearray to numpy array
line_feedrates = line_feedrates.reshape(
(-1, 1)
) # We get a linear list of pairs that make up the points, so make numpy interpret them correctly.
### START PATCH
# Adjust layer data to show Raft line type, if it is enabled
if self._preferences.getValue("BeltPlugin/raft"):
raft_thickness = self._preferences.getValue(
"BeltPlugin/raft_thickness")
extrusion_started = False
for index, segment_type in enumerate(line_types):
if points[index + 1][
1] <= half_outer_wall_thickness + raft_thickness:
if segment_type in [
LayerPolygon.LayerPolygon.Inset0Type,
LayerPolygon.LayerPolygon.InsetXType
]:
line_types[
index] = LayerPolygon.LayerPolygon.SkirtType
extrusion_started = True
elif extrusion_started:
break
# Adjust layer data to show Belt Wall feed rate, if it is enabled
if self._preferences.getValue("BeltPlugin/belt_wall_enabled"):
belt_wall_feedrate = self._preferences.getValue(
"BeltPlugin/belt_wall_speed")
belt_wall_indices = []
for index, point in enumerate(points):
if point[1] <= half_outer_wall_thickness + EPSILON:
if last_point_hit_wall and line_feedrates[
index - 1] > belt_wall_feedrate:
belt_wall_indices.append(index)
last_point_hit_wall = True
else:
last_point_hit_wall = False
dimensionality = points.shape[1]
edited_points = points.flatten()
line_types = line_types.flatten()
line_widths = line_widths.flatten()
line_thicknesses = line_thicknesses.flatten()
line_feedrates = line_feedrates.flatten()
for index in reversed(belt_wall_indices):
edited_points = numpy.insert(
edited_points, dimensionality * (index),
numpy.append(points[index - 1], points[index]))
line_types = numpy.insert(line_types, index,
[line_types[index - 1]] * 2)
line_widths = numpy.insert(
line_widths, index, [line_widths[index - 1]] * 2)
line_thicknesses = numpy.insert(
line_thicknesses, index,
[line_thicknesses[index - 1]] * 2)
line_feedrates = numpy.insert(line_feedrates,
index - 1,
[belt_wall_feedrate] * 2)
# Fix shape of adjusted data
if polygon.point_type == 0:
points = edited_points.reshape(
(-1, 2)
) # We get a linear list of pairs that make up the points, so make numpy interpret them correctly.
else:
points = edited_points.reshape((-1, 3))
line_types = line_types.reshape((-1, 1))
line_widths = line_widths.reshape((-1, 1))
line_thicknesses = line_thicknesses.reshape((-1, 1))
line_feedrates = line_feedrates.reshape((-1, 1))
### END PATCH
# Create a new 3D-array, copy the 2D points over and insert the right height.
# This uses manual array creation + copy rather than numpy.insert since this is
# faster.
new_points = numpy.empty((len(points), 3), numpy.float32)
if polygon.point_type == 0: # Point2D
new_points[:, 0] = points[:, 0]
new_points[:,
1] = layer.height / 1000 # layer height value is in backend representation
new_points[:, 2] = -points[:, 1]
else: # Point3D
new_points[:, 0] = points[:, 0]
new_points[:, 1] = points[:, 2]
new_points[:, 2] = -points[:, 1]
this_poly = LayerPolygon.LayerPolygon(extruder, line_types,
new_points, line_widths,
line_thicknesses,
line_feedrates)
this_poly.buildCache()
this_layer.polygons.append(this_poly)
Job.yieldThread()
Job.yieldThread()
current_layer += 1
progress = (current_layer / layer_count) * 99
# TODO: Rebuild the layer data mesh once the layer has been processed.
# This needs some work in LayerData so we can add the new layers instead of recreating the entire mesh.
if self._abort_requested:
if self._progress_message:
self._progress_message.hide()
return
if self._progress_message:
self._progress_message.setProgress(progress)
# We are done processing all the layers we got from the engine, now create a mesh out of the data
# Find out colors per extruder
global_container_stack = Application.getInstance(
).getGlobalContainerStack()
manager = ExtruderManager.getInstance()
extruders = manager.getActiveExtruderStacks()
if extruders:
material_color_map = numpy.zeros((len(extruders), 4),
dtype=numpy.float32)
for extruder in extruders:
position = int(
extruder.getMetaDataEntry("position",
default="0")) # Get the position
try:
default_color = ExtrudersModel.defaultColors[position]
except IndexError:
default_color = "#e0e000"
color_code = extruder.material.getMetaDataEntry(
"color_code", default=default_color)
color = colorCodeToRGBA(color_code)
material_color_map[position, :] = color
else:
# Single extruder via global stack.
material_color_map = numpy.zeros((1, 4), dtype=numpy.float32)
color_code = global_container_stack.material.getMetaDataEntry(
"color_code", default="#e0e000")
color = colorCodeToRGBA(color_code)
material_color_map[0, :] = color
# We have to scale the colors for compatibility mode
if OpenGLContext.isLegacyOpenGL() or bool(
Application.getInstance().getPreferences().getValue(
"view/force_layer_view_compatibility_mode")):
line_type_brightness = 0.5 # for compatibility mode
else:
line_type_brightness = 1.0
layer_mesh = layer_data.build(material_color_map, line_type_brightness)
if self._abort_requested:
if self._progress_message:
self._progress_message.hide()
return
# Add LayerDataDecorator to scene node to indicate that the node has layer data
decorator = LayerDataDecorator.LayerDataDecorator()
decorator.setLayerData(layer_mesh)
new_node.addDecorator(decorator)
new_node.setMeshData(mesh)
# Set build volume as parent, the build volume can move as a result of raft settings.
# It makes sense to set the build volume as parent: the print is actually printed on it.
new_node_parent = Application.getInstance().getBuildVolume()
new_node.setParent(
new_node_parent) # Note: After this we can no longer abort!
settings = Application.getInstance().getGlobalContainerStack()
if not settings.getProperty("machine_center_is_zero", "value"):
new_node.setPosition(
Vector(-settings.getProperty("machine_width", "value") / 2,
0.0,
settings.getProperty("machine_depth", "value") / 2))
### START PATCH
transform = self._scene.getRoot().callDecoration("getTransformMatrix")
if transform and transform != Matrix():
transform_matrix = new_node.getLocalTransformation().preMultiply(
transform.getInverse())
new_node.setTransformation(transform_matrix)
front_offset = self._scene.getRoot().callDecoration(
"getSceneFrontOffset")
if self._preferences.getValue("BeltPlugin/raft"):
front_offset = front_offset - self._preferences.getValue("BeltPlugin/raft_margin") \
- self._preferences.getValue("BeltPlugin/raft_thickness")
new_node.translate(Vector(0, 0, front_offset),
SceneNode.TransformSpace.World)
### END PATCH
if self._progress_message:
self._progress_message.setProgress(100)
if self._progress_message:
self._progress_message.hide()
# Clear the unparsed layers. This saves us a bunch of memory if the Job does not get destroyed.
self._layers = None
Logger.log("d", "Processing layers took %s seconds",
time() - start_time)
