Cura/cura/Arrange.py

import numpy as np

##  Some polygon converted to an array
class ShapeArray:
    def __init__(self, arr, offset_x, offset_y, scale = 1):
        self.arr = arr
        self.offset_x = offset_x
        self.offset_y = offset_y
        self.scale = scale

    @classmethod
    def from_polygon(cls, vertices, scale = 1):
        # scale
        vertices = vertices * scale
        # flip y, x -> x, y
        flip_vertices = np.zeros((vertices.shape))
        flip_vertices[:, 0] = vertices[:, 1]
        flip_vertices[:, 1] = vertices[:, 0]
        flip_vertices = flip_vertices[::-1]
        # offset, we want that all coordinates have positive values
        offset_y = int(np.amin(flip_vertices[:, 0]))
        offset_x = int(np.amin(flip_vertices[:, 1]))
        flip_vertices[:, 0] = np.add(flip_vertices[:, 0], -offset_y)
        flip_vertices[:, 1] = np.add(flip_vertices[:, 1], -offset_x)
        shape = [int(np.amax(flip_vertices[:, 0])), int(np.amax(flip_vertices[:, 1]))]
        arr = cls.array_from_polygon(shape, flip_vertices)
        return cls(arr, offset_x, offset_y)

    #   Originally from: http://stackoverflow.com/questions/37117878/generating-a-filled-polygon-inside-a-numpy-array
    @classmethod
    def array_from_polygon(cls, shape, vertices):
        """
        Creates np.array with dimensions defined by shape
        Fills polygon defined by vertices with ones, all other values zero

        Only works correctly for convex hull vertices
        """
        base_array = np.zeros(shape, dtype=float)  # Initialize your array of zeros

        fill = np.ones(base_array.shape) * True  # Initialize boolean array defining shape fill

        # Create check array for each edge segment, combine into fill array
        for k in range(vertices.shape[0]):
            fill = np.all([fill, cls._check(vertices[k - 1], vertices[k], base_array)], axis=0)

        # Set all values inside polygon to one
        base_array[fill] = 1

        return base_array

    ##  Return indices that mark one side of the line, used by array_from_polygon
    #   Uses the line defined by p1 and p2 to check array of
    #   input indices against interpolated value

    #   Returns boolean array, with True inside and False outside of shape
    #   Originally from: http://stackoverflow.com/questions/37117878/generating-a-filled-polygon-inside-a-numpy-array
    @classmethod
    def _check(cls, p1, p2, base_array):
        if p1[0] == p2[0] and p1[1] == p2[1]:
            return
        idxs = np.indices(base_array.shape)  # Create 3D array of indices

        p1 = p1.astype(float)
        p2 = p2.astype(float)

        if p2[0] == p1[0]:
            sign = np.sign(p2[1] - p1[1])
            return idxs[1] * sign

        if p2[1] == p1[1]:
            sign = np.sign(p2[0] - p1[0])
            return idxs[1] * sign

        # Calculate max column idx for each row idx based on interpolated line between two points

        max_col_idx = (idxs[0] - p1[0]) / (p2[0] - p1[0]) * (p2[1] - p1[1]) + p1[1]
        sign = np.sign(p2[0] - p1[0])
        return idxs[1] * sign <= max_col_idx * sign


class Arrange:
    def __init__(self, x, y, offset_x, offset_y, scale=1):
        self.shape = (y, x)
        self._priority = np.zeros((x, y), dtype=np.int32)
        self._priority_unique_values = []
        self._occupied = np.zeros((x, y), dtype=np.int32)
        self._scale = scale  # convert input coordinates to arrange coordinates
        self._offset_x = offset_x
        self._offset_y = offset_y

    ##  Fill priority, take offset as center. lower is better
    def centerFirst(self):
        # Distance x + distance y
        #self._priority = np.fromfunction(
        #    lambda i, j: abs(self._offset_x-i)+abs(self._offset_y-j), self.shape, dtype=np.int32)
        # Square distance
        # self._priority = np.fromfunction(
        #     lambda i, j: abs(self._offset_x-i)**2+abs(self._offset_y-j)**2, self.shape, dtype=np.int32)
        self._priority = np.fromfunction(
            lambda i, j: abs(self._offset_x-i)**3+abs(self._offset_y-j)**3, self.shape, dtype=np.int32)
        # self._priority = np.fromfunction(
        #    lambda i, j: max(abs(self._offset_x-i), abs(self._offset_y-j)), self.shape, dtype=np.int32)
        self._priority_unique_values = np.unique(self._priority)
        self._priority_unique_values.sort()

    ##  Return the amount of "penalty points" for polygon, which is the sum of priority
    #   999999 if occupied
    def check_shape(self, x, y, shape_arr):
        x = int(self._scale * x)
        y = int(self._scale * y)
        offset_x = x + self._offset_x + shape_arr.offset_x
        offset_y = y + self._offset_y + shape_arr.offset_y
        occupied_slice = self._occupied[
            offset_y:offset_y + shape_arr.arr.shape[0],
            offset_x:offset_x + shape_arr.arr.shape[1]]
        try:
            if np.any(occupied_slice[np.where(shape_arr.arr == 1)]):
                return 999999
        except IndexError:  # out of bounds if you try to place an object outside
            return 999999
        prio_slice = self._priority[
            offset_y:offset_y + shape_arr.arr.shape[0],
            offset_x:offset_x + shape_arr.arr.shape[1]]
        return np.sum(prio_slice[np.where(shape_arr.arr == 1)])

    ##  Find "best" spot
    def bestSpot(self, shape_arr, start_prio = 0, step = 1):
        start_idx_list = np.where(self._priority_unique_values == start_prio)
        if start_idx_list:
            start_idx = start_idx_list[0]
        else:
            start_idx = 0
        for prio in self._priority_unique_values[start_idx::step]:
            tryout_idx = np.where(self._priority == prio)
            for idx in range(len(tryout_idx[0])):
                x = tryout_idx[0][idx]
                y = tryout_idx[1][idx]
                projected_x = x - self._offset_x
                projected_y = y - self._offset_y

                # array to "world" coordinates
                penalty_points = self.check_shape(projected_x, projected_y, shape_arr)
                if penalty_points != 999999:
                    return projected_x, projected_y, penalty_points, prio
        return None, None, None, prio  # No suitable location found :-(

    ##  Place the object
    def place(self, x, y, shape_arr):
        x = int(self._scale * x)
        y = int(self._scale * y)
        offset_x = x + self._offset_x + shape_arr.offset_x
        offset_y = y + self._offset_y + shape_arr.offset_y
        shape_y, shape_x = self._occupied.shape

        min_x = min(max(offset_x, 0), shape_x - 1)
        min_y = min(max(offset_y, 0), shape_y - 1)
        max_x = min(max(offset_x + shape_arr.arr.shape[1], 0), shape_x - 1)
        max_y = min(max(offset_y + shape_arr.arr.shape[0], 0), shape_y - 1)
        occupied_slice = self._occupied[min_y:max_y, min_x:max_x]
        # we use a slice of shape because it can be out of bounds
        occupied_slice[np.where(shape_arr.arr[
            min_y - offset_y:max_y - offset_y, min_x - offset_x:max_x - offset_x] == 1)] = 1

        # Set priority to low (= high number), so it won't get picked at trying out.
        prio_slice = self._priority[min_y:max_y, min_x:max_x]
        prio_slice[np.where(shape_arr.arr[
            min_y - offset_y:max_y - offset_y, min_x - offset_x:max_x - offset_x] == 1)] = 999