# Copyright (c) 2020 Ultimaker B.V. # Cura is released under the terms of the LGPLv3 or higher. import numpy from pynest2d import Point, Box, Item, NfpConfig, nest from typing import List, TYPE_CHECKING, Optional, Tuple from UM.Application import Application from UM.Decorators import deprecated from UM.Logger import Logger from UM.Math.Matrix import Matrix from UM.Math.Polygon import Polygon from UM.Math.Quaternion import Quaternion from UM.Math.Vector import Vector from UM.Operations.AddSceneNodeOperation import AddSceneNodeOperation from UM.Operations.GroupedOperation import GroupedOperation from UM.Operations.RotateOperation import RotateOperation from UM.Operations.TranslateOperation import TranslateOperation from cura.Arranging.Arranger import Arranger if TYPE_CHECKING: from UM.Scene.SceneNode import SceneNode from cura.BuildVolume import BuildVolume class Nest2DArrange(Arranger): def __init__(self, nodes_to_arrange: List["SceneNode"], build_volume: "BuildVolume", fixed_nodes: Optional[List["SceneNode"]] = None, *, factor: int = 10000, lock_rotation: bool = False): """ :param nodes_to_arrange: The list of nodes that need to be moved. :param build_volume: The build volume that we want to place the nodes in. It gets size & disallowed areas from this. :param fixed_nodes: List of nods that should not be moved, but should be used when deciding where the others nodes are placed. :param factor: The library that we use is int based. This factor defines how accuracte we want it to be. :param lock_rotation: If set to true the orientation of the object will remain the same """ super().__init__() self._nodes_to_arrange = nodes_to_arrange self._build_volume = build_volume self._fixed_nodes = fixed_nodes self._factor = factor self._lock_rotation = lock_rotation def findNodePlacement(self) -> Tuple[bool, List[Item]]: spacing = int(1.5 * self._factor) # 1.5mm spacing. machine_width = self._build_volume.getWidth() machine_depth = self._build_volume.getDepth() build_plate_bounding_box = Box(int(machine_width * self._factor), int(machine_depth * self._factor)) if self._fixed_nodes is None: self._fixed_nodes = [] # Add all the items we want to arrange node_items = [] for node in self._nodes_to_arrange: hull_polygon = node.callDecoration("getConvexHull") if not hull_polygon or hull_polygon.getPoints is None: Logger.log("w", "Object {} cannot be arranged because it has no convex hull.".format(node.getName())) continue converted_points = [] for point in hull_polygon.getPoints(): converted_points.append(Point(int(point[0] * self._factor), int(point[1] * self._factor))) item = Item(converted_points) node_items.append(item) # Use a tiny margin for the build_plate_polygon (the nesting doesn't like overlapping disallowed areas) half_machine_width = 0.5 * machine_width - 1 half_machine_depth = 0.5 * machine_depth - 1 build_plate_polygon = Polygon(numpy.array([ [half_machine_width, -half_machine_depth], [-half_machine_width, -half_machine_depth], [-half_machine_width, half_machine_depth], [half_machine_width, half_machine_depth] ], numpy.float32)) disallowed_areas = self._build_volume.getDisallowedAreas() num_disallowed_areas_added = 0 for area in disallowed_areas: converted_points = [] # Clip the disallowed areas so that they don't overlap the bounding box (The arranger chokes otherwise) clipped_area = area.intersectionConvexHulls(build_plate_polygon) if clipped_area.getPoints() is not None and len( clipped_area.getPoints()) > 2: # numpy array has to be explicitly checked against None for point in clipped_area.getPoints(): converted_points.append(Point(int(point[0] * self._factor), int(point[1] * self._factor))) disallowed_area = Item(converted_points) disallowed_area.markAsDisallowedAreaInBin(0) node_items.append(disallowed_area) num_disallowed_areas_added += 1 for node in self._fixed_nodes: converted_points = [] hull_polygon = node.callDecoration("getConvexHull") if hull_polygon is not None and hull_polygon.getPoints() is not None and len( hull_polygon.getPoints()) > 2: # numpy array has to be explicitly checked against None for point in hull_polygon.getPoints(): converted_points.append(Point(int(point[0] * self._factor), int(point[1] * self._factor))) item = Item(converted_points) item.markAsFixedInBin(0) node_items.append(item) num_disallowed_areas_added += 1 config = NfpConfig() config.accuracy = 1.0 config.alignment = NfpConfig.Alignment.DONT_ALIGN if self._lock_rotation: config.rotations = [0.0] num_bins = nest(node_items, build_plate_bounding_box, spacing, config) # Strip the fixed items (previously placed) and the disallowed areas from the results again. node_items = list(filter(lambda item: not item.isFixed(), node_items)) found_solution_for_all = num_bins == 1 return found_solution_for_all, node_items def createGroupOperationForArrange(self, add_new_nodes_in_scene: bool = False) -> Tuple[GroupedOperation, int]: scene_root = Application.getInstance().getController().getScene().getRoot() found_solution_for_all, node_items = self.findNodePlacement() not_fit_count = 0 grouped_operation = GroupedOperation() for node, node_item in zip(self._nodes_to_arrange, node_items): if add_new_nodes_in_scene: grouped_operation.addOperation(AddSceneNodeOperation(node, scene_root)) if node_item.binId() == 0: # We found a spot for it rotation_matrix = Matrix() rotation_matrix.setByRotationAxis(node_item.rotation(), Vector(0, -1, 0)) grouped_operation.addOperation(RotateOperation(node, Quaternion.fromMatrix(rotation_matrix))) grouped_operation.addOperation( TranslateOperation(node, Vector(node_item.translation().x() / self._factor, 0, node_item.translation().y() / self._factor))) else: # We didn't find a spot grouped_operation.addOperation( TranslateOperation(node, Vector(200, node.getWorldPosition().y, -not_fit_count * 20), set_position = True)) not_fit_count += 1 return grouped_operation, not_fit_count @deprecated("Use the Nest2DArrange class instead") def findNodePlacement(nodes_to_arrange: List["SceneNode"], build_volume: "BuildVolume", fixed_nodes: Optional[List["SceneNode"]] = None, factor=10000) -> Tuple[bool, List[Item]]: arranger = Nest2DArrange(nodes_to_arrange, build_volume, fixed_nodes, factor=factor) return arranger.findNodePlacement() @deprecated("Use the Nest2DArrange class instead") def createGroupOperationForArrange(nodes_to_arrange: List["SceneNode"], build_volume: "BuildVolume", fixed_nodes: Optional[List["SceneNode"]] = None, factor=10000, add_new_nodes_in_scene: bool = False) -> Tuple[GroupedOperation, int]: arranger = Nest2DArrange(nodes_to_arrange, build_volume, fixed_nodes, factor=factor) return arranger.createGroupOperationForArrange(add_new_nodes_in_scene=add_new_nodes_in_scene) @deprecated("Use the Nest2DArrange class instead") def arrange(nodes_to_arrange: List["SceneNode"], build_volume: "BuildVolume", fixed_nodes: Optional[List["SceneNode"]] = None, factor=10000, add_new_nodes_in_scene: bool = False) -> bool: arranger = Nest2DArrange(nodes_to_arrange, build_volume, fixed_nodes, factor=factor) return arranger.arrange(add_new_nodes_in_scene=add_new_nodes_in_scene)