def run(self):
status_message = Message(
i18n_catalog.i18nc("@info:status",
"Finding new location for objects"),
lifetime=0,
dismissable=False,
progress=0,
title=i18n_catalog.i18nc("@info:title", "Finding Location"))
status_message.show()
global_container_stack = Application.getInstance(
).getGlobalContainerStack()
machine_width = global_container_stack.getProperty(
"machine_width", "value")
machine_depth = global_container_stack.getProperty(
"machine_depth", "value")
arranger = Arrange.create(x=machine_width,
y=machine_depth,
fixed_nodes=self._fixed_nodes,
min_offset=self._min_offset)
# Collect nodes to be placed
nodes_arr = [
] # fill with (size, node, offset_shape_arr, hull_shape_arr)
for node in self._nodes:
offset_shape_arr, hull_shape_arr = ShapeArray.fromNode(
node, min_offset=self._min_offset)
if offset_shape_arr is None:
Logger.log(
"w",
"Node [%s] could not be converted to an array for arranging...",
str(node))
continue
nodes_arr.append(
(offset_shape_arr.arr.shape[0] * offset_shape_arr.arr.shape[1],
node, offset_shape_arr, hull_shape_arr))
# Sort the nodes with the biggest area first.
nodes_arr.sort(key=lambda item: item[0])
nodes_arr.reverse()
# Place nodes one at a time
start_priority = 0
last_priority = start_priority
last_size = None
grouped_operation = GroupedOperation()
found_solution_for_all = True
not_fit_count = 0
for idx, (size, node, offset_shape_arr,
hull_shape_arr) in enumerate(nodes_arr):
# For performance reasons, we assume that when a location does not fit,
# it will also not fit for the next object (while what can be untrue).
if last_size == size: # This optimization works if many of the objects have the same size
start_priority = last_priority
else:
start_priority = 0
best_spot = arranger.bestSpot(hull_shape_arr,
start_prio=start_priority)
x, y = best_spot.x, best_spot.y
node.removeDecorator(ZOffsetDecorator)
if node.getBoundingBox():
center_y = node.getWorldPosition().y - node.getBoundingBox(
).bottom
else:
center_y = 0
if x is not None: # We could find a place
last_size = size
last_priority = best_spot.priority
arranger.place(
x, y, offset_shape_arr) # take place before the next one
grouped_operation.addOperation(
TranslateOperation(node,
Vector(x, center_y, y),
set_position=True))
else:
Logger.log("d", "Arrange all: could not find spot!")
found_solution_for_all = False
grouped_operation.addOperation(
TranslateOperation(node,
Vector(200, center_y,
-not_fit_count * 20),
set_position=True))
not_fit_count += 1
status_message.setProgress((idx + 1) / len(nodes_arr) * 100)
Job.yieldThread()
grouped_operation.push()
status_message.hide()
if not found_solution_for_all:
no_full_solution_message = Message(i18n_catalog.i18nc(
"@info:status",
"Unable to find a location within the build volume for all objects"
),
title=i18n_catalog.i18nc(
"@info:title",
"Can't Find Location"))
no_full_solution_message.show()
self.finished.emit(self)
def add(self):
new_arrange = Arrange.create(x = self._x, y = self._y, fixed_nodes = self._fixed_nodes)
self._arrange.append(new_arrange)
self._count += 1
self._update_first_empty()
def test_smoke_arrange():
ar = Arrange.create(fixed_nodes=[])
def run(self):
status_message = Message(
i18n_catalog.i18nc("@info:status",
"Multiplying and placing objects"),
lifetime=0,
dismissable=False,
progress=0,
title=i18n_catalog.i18nc("@info:title", "Placing Object"))
status_message.show()
scene = Application.getInstance().getController().getScene()
total_progress = len(self._objects) * self._count
current_progress = 0
global_container_stack = Application.getInstance(
).getGlobalContainerStack()
machine_width = global_container_stack.getProperty(
"machine_width", "value")
machine_depth = global_container_stack.getProperty(
"machine_depth", "value")
root = scene.getRoot()
scale = 0.5
arranger = Arrange.create(x=machine_width,
y=machine_depth,
scene_root=root,
scale=scale,
min_offset=self._min_offset)
processed_nodes = []
nodes = []
not_fit_count = 0
for node in self._objects:
# If object is part of a group, multiply group
current_node = node
while current_node.getParent() and (
current_node.getParent().callDecoration("isGroup")
or current_node.getParent().callDecoration("isSliceable")):
current_node = current_node.getParent()
if current_node in processed_nodes:
continue
processed_nodes.append(current_node)
node_too_big = False
if node.getBoundingBox(
).width < machine_width or node.getBoundingBox(
).depth < machine_depth:
offset_shape_arr, hull_shape_arr = ShapeArray.fromNode(
current_node, min_offset=self._min_offset, scale=scale)
else:
node_too_big = True
found_solution_for_all = True
arranger.resetLastPriority()
for i in range(self._count):
# We do place the nodes one by one, as we want to yield in between.
new_node = copy.deepcopy(node)
solution_found = False
if not node_too_big:
solution_found = arranger.findNodePlacement(
new_node, offset_shape_arr, hull_shape_arr)
if node_too_big or not solution_found:
found_solution_for_all = False
new_location = new_node.getPosition()
new_location = new_location.set(z=-not_fit_count * 20)
new_node.setPosition(new_location)
not_fit_count += 1
# Same build plate
build_plate_number = current_node.callDecoration(
"getBuildPlateNumber")
new_node.callDecoration("setBuildPlateNumber",
build_plate_number)
for child in new_node.getChildren():
child.callDecoration("setBuildPlateNumber",
build_plate_number)
nodes.append(new_node)
current_progress += 1
status_message.setProgress(
(current_progress / total_progress) * 100)
Job.yieldThread()
Job.yieldThread()
if nodes:
op = GroupedOperation()
for new_node in nodes:
op.addOperation(
AddSceneNodeOperation(new_node, current_node.getParent()))
op.push()
status_message.hide()
if not found_solution_for_all:
no_full_solution_message = Message(i18n_catalog.i18nc(
"@info:status",
"Unable to find a location within the build volume for all objects"
),
title=i18n_catalog.i18nc(
"@info:title",
"Placing Object"))
no_full_solution_message.show()