Update Files

leenkx/blender/lnx/lightmapper/utility/rectpack/maxrects.py

@@ -0,0 +1,244 @@
+from .pack_algo import PackingAlgorithm
+from .geometry import Rectangle
+import itertools
+import collections
+import operator
+
+
+first_item = operator.itemgetter(0)
+
+
+
+class MaxRects(PackingAlgorithm):
+
+    def __init__(self, width, height, rot=True, *args, **kwargs):
+        super(MaxRects, self).__init__(width, height, rot, *args, **kwargs)
+   
+    def _rect_fitness(self, max_rect, width, height):
+        """
+        Arguments:
+            max_rect (Rectangle): Destination max_rect
+            width (int, float): Rectangle width
+            height (int, float): Rectangle height
+
+        Returns:
+            None: Rectangle couldn't be placed into max_rect
+            integer, float: fitness value 
+        """
+        if width <= max_rect.width and height <= max_rect.height:
+            return 0
+        else:
+            return None
+
+    def _select_position(self, w, h): 
+        """
+        Find max_rect with best fitness for placing a rectangle
+        of dimentsions w*h
+
+        Arguments:
+            w (int, float): Rectangle width
+            h (int, float): Rectangle height
+
+        Returns:
+            (rect, max_rect)
+            rect (Rectangle): Placed rectangle or None if was unable.
+            max_rect (Rectangle): Maximal rectangle were rect was placed
+        """
+        if not self._max_rects:
+            return None, None
+
+        # Normal rectangle
+        fitn = ((self._rect_fitness(m, w, h), w, h, m) for m in self._max_rects 
+                if self._rect_fitness(m, w, h) is not None)
+
+        # Rotated rectangle
+        fitr = ((self._rect_fitness(m, h, w), h, w, m) for m in self._max_rects 
+                if self._rect_fitness(m, h, w) is not None)
+
+        if not self.rot:
+            fitr = []
+
+        fit = itertools.chain(fitn, fitr)
+        
+        try:
+            _, w, h, m = min(fit, key=first_item)
+        except ValueError:
+            return None, None
+
+        return Rectangle(m.x, m.y, w, h), m
+
+    def _generate_splits(self, m, r):
+        """
+        When a rectangle is placed inside a maximal rectangle, it stops being one
+        and up to 4 new maximal rectangles may appear depending on the placement.
+        _generate_splits calculates them.
+
+        Arguments:
+            m (Rectangle): max_rect rectangle
+            r (Rectangle): rectangle placed
+
+        Returns:
+            list : list containing new maximal rectangles or an empty list
+        """
+        new_rects = []
+        
+        if r.left > m.left:
+            new_rects.append(Rectangle(m.left, m.bottom, r.left-m.left, m.height))
+        if r.right < m.right:
+            new_rects.append(Rectangle(r.right, m.bottom, m.right-r.right, m.height))
+        if r.top < m.top:
+            new_rects.append(Rectangle(m.left, r.top, m.width, m.top-r.top))
+        if r.bottom > m.bottom:
+            new_rects.append(Rectangle(m.left, m.bottom, m.width, r.bottom-m.bottom))
+        
+        return new_rects
+
+    def _split(self, rect):
+        """
+        Split all max_rects intersecting the rectangle rect into up to
+        4 new max_rects.
+        
+        Arguments:
+            rect (Rectangle): Rectangle
+
+        Returns:
+            split (Rectangle list): List of rectangles resulting from the split
+        """
+        max_rects = collections.deque()
+
+        for r in self._max_rects:
+            if r.intersects(rect):
+                max_rects.extend(self._generate_splits(r, rect))
+            else:
+                max_rects.append(r)
+
+        # Add newly generated max_rects
+        self._max_rects = list(max_rects)
+
+    def _remove_duplicates(self):
+        """
+        Remove every maximal rectangle contained by another one.
+        """
+        contained = set()
+        for m1, m2 in itertools.combinations(self._max_rects, 2):
+            if m1.contains(m2):
+                contained.add(m2)
+            elif m2.contains(m1):
+                contained.add(m1)
+        
+        # Remove from max_rects
+        self._max_rects = [m for m in self._max_rects if m not in contained]
+
+    def fitness(self, width, height): 
+        """
+        Metric used to rate how much space is wasted if a rectangle is placed.
+        Returns a value greater or equal to zero, the smaller the value the more 
+        'fit' is the rectangle. If the rectangle can't be placed, returns None.
+
+        Arguments:
+            width (int, float): Rectangle width
+            height (int, float): Rectangle height
+
+        Returns:
+            int, float: Rectangle fitness 
+            None: Rectangle can't be placed
+        """
+        assert(width > 0 and height > 0)
+        
+        rect, max_rect = self._select_position(width, height)
+        if rect is None:
+            return None
+
+        # Return fitness
+        return self._rect_fitness(max_rect, rect.width, rect.height)
+
+    def add_rect(self, width, height, rid=None):
+        """
+        Add rectangle of widthxheight dimensions.
+
+        Arguments:
+            width (int, float): Rectangle width
+            height (int, float): Rectangle height
+            rid: Optional rectangle user id
+
+        Returns:
+            Rectangle: Rectangle with placemente coordinates
+            None: If the rectangle couldn be placed.
+        """
+        assert(width > 0 and height >0)
+
+        # Search best position and orientation
+        rect, _ = self._select_position(width, height)
+        if not rect:
+            return None
+        
+        # Subdivide all the max rectangles intersecting with the selected 
+        # rectangle.
+        self._split(rect)
+    
+        # Remove any max_rect contained by another 
+        self._remove_duplicates()
+
+        # Store and return rectangle position.
+        rect.rid = rid
+        self.rectangles.append(rect)
+        return rect
+
+    def reset(self):
+        super(MaxRects, self).reset()
+        self._max_rects = [Rectangle(0, 0, self.width, self.height)]
+
+
+
+
+class MaxRectsBl(MaxRects):
+    
+    def _select_position(self, w, h): 
+        """
+        Select the position where the y coordinate of the top of the rectangle
+        is lower, if there are severtal pick the one with the smallest x 
+        coordinate
+        """
+        fitn = ((m.y+h, m.x, w, h, m) for m in self._max_rects 
+                if self._rect_fitness(m, w, h) is not None)
+        fitr = ((m.y+w, m.x, h, w, m) for m in self._max_rects 
+                if self._rect_fitness(m, h, w) is not None)
+
+        if not self.rot:
+            fitr = []
+
+        fit = itertools.chain(fitn, fitr)
+        
+        try:
+            _, _, w, h, m = min(fit, key=first_item)
+        except ValueError:
+            return None, None
+
+        return Rectangle(m.x, m.y, w, h), m
+
+
+class MaxRectsBssf(MaxRects):
+    """Best Sort Side Fit minimize short leftover side"""
+    def _rect_fitness(self, max_rect, width, height):
+        if width > max_rect.width or height > max_rect.height:
+            return None
+
+        return min(max_rect.width-width, max_rect.height-height)
+           
+class MaxRectsBaf(MaxRects):
+    """Best Area Fit pick maximal rectangle with smallest area
+    where the rectangle can be placed"""
+    def _rect_fitness(self, max_rect, width, height):
+        if width > max_rect.width or height > max_rect.height:
+            return None
+        
+        return (max_rect.width*max_rect.height)-(width*height)
+
+
+class MaxRectsBlsf(MaxRects):
+    """Best Long Side Fit minimize long leftover side"""
+    def _rect_fitness(self, max_rect, width, height):
+        if width > max_rect.width or height > max_rect.height:
+            return None
+
+        return max(max_rect.width-width, max_rect.height-height)