def METHOD_NAME(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