simetri.graphics.bbox

  1"""Bounding box class. Shape and Batch objects have a bounding box.
  2Bounding box is axis-aligned. Provides reference edges and points.
  3"""
  4import warnings
  5
  6import numpy as np
  7from .common import Point, common_properties, defaults
  8from .all_enums import Side, Types, Anchor
  9from ..geometry.geometry import (
 10    distance,
 11    mid_point,
 12    offset_line,
 13    line_angle,
 14    intersect,
 15    positive_angle,
 16    polar_to_cartesian
 17)
 18
 19
 20class BoundingBox:
 21    """Rectangular bounding box.
 22    If the object is a Shape, it contains all points.
 23    If the object is a Batch, it contains all points of all Shapes.
 24
 25    Provides reference edges and points as shown in the Book page ???.
 26    """
 27
 28    def __init__(self, southwest: Point, northeast: Point):
 29        """
 30        Initialize a BoundingBox object.
 31
 32        Args:
 33            southwest (Point): The southwest corner of the bounding box.
 34            northeast (Point): The northeast corner of the bounding box.
 35        """
 36        # define the four corners
 37        self.__dict__["southwest"] = southwest
 38        self.__dict__["northeast"] = northeast
 39        self.__dict__["northwest"] = (southwest[0], northeast[1])
 40        self.__dict__["southeast"] = (northeast[0], southwest[1])
 41        self._aliases = {
 42            "s": "south",
 43            "n": "north",
 44            "w": "west",
 45            "e": "east",
 46            "sw": "southwest",
 47            "se": "southeast",
 48            "nw": "northwest",
 49            "ne": "northeast",
 50            "d1": "diagonal1",
 51            "d2": "diagonal2",
 52            "m": "midpoint",
 53            "vcl": "vert_centerline",
 54            "hcl": "horiz_centerline",
 55            "center": "midpoint",
 56        }
 57
 58        common_properties(self)
 59        self.type = Types.BOUNDING_BOX
 60        self.subtype = Types.BOUNDING_BOX
 61
 62    def __getattr__(self, name):
 63        """
 64        Get the attribute with the given name.
 65
 66        Args:
 67            name (str): The name of the attribute.
 68
 69        Returns:
 70            Any: The attribute with the given name.
 71        """
 72        if name in self._aliases:
 73            if name == "center":
 74                warnings.warn('"center" is deprecated use "midpoint" instead.', DeprecationWarning)
 75            res = getattr(self, self._aliases[name])
 76        else:
 77            res = self.__dict__[name]
 78        return res
 79
 80    def angle_point(self, angle: float) -> float:
 81        """
 82        Return the intersection point of the angled line starting
 83        from the midpoint and the bounding box. angle is in radians.
 84
 85        Args:
 86            angle (float): The angle in radians.
 87
 88        Returns:
 89            float: The intersection point.
 90        """
 91        angle = positive_angle(angle)
 92        line = ((0, 0), (np.cos(angle), np.sin(angle)))
 93
 94        angle1 = line_angle(self.midpoint, self.northeast)
 95        angle2 = -angle1  # midpoint, southeast
 96        angle3 = np.pi - angle1  # midpoint, northwest
 97        angle4 = -angle3  # midpoint, southwest
 98        if angle3 >= angle >= angle1:
 99            res = intersect(line, self.top)
100        elif angle4 <= angle <= angle2:
101            res = intersect(line, self.bottom)
102        elif angle1 <= angle <= angle2:
103            res = intersect(line, self.right)
104        else:
105            res = intersect(line, self.left)
106
107        return res
108
109    @property
110    def left(self):
111        """
112        Return the left edge.
113
114        Returns:
115            tuple: The left edge.
116        """
117        return (self.northwest, self.southwest)
118
119    @property
120    def right(self):
121        """
122        Return the right edge.
123
124        Returns:
125            tuple: The right edge.
126        """
127        return (self.northeast, self.southeast)
128
129    @property
130    def top(self):
131        """
132        Return the top edge.
133
134        Returns:
135            tuple: The top edge.
136        """
137        return (self.northwest, self.northeast)
138
139    @property
140    def bottom(self):
141        """
142        Return the bottom edge.
143
144        Returns:
145            tuple: The bottom edge.
146        """
147        return (self.southwest, self.southeast)
148
149    @property
150    def vert_centerline(self):
151        """
152        Return the vertical centerline.
153
154        Returns:
155            tuple: The vertical centerline.
156        """
157        return (self.north, self.south)
158
159    @property
160    def horiz_centerline(self):
161        """
162        Return the horizontal centerline.
163
164        Returns:
165            tuple: The horizontal centerline.
166        """
167        return (self.west, self.east)
168
169    @property
170    def midpoint(self):
171        """
172        Return the center of the bounding box.
173
174        Returns:
175            tuple: The center of the bounding box.
176        """
177        x1, y1 = self.southwest
178        x2, y2 = self.northeast
179
180        xc = (x1 + x2) / 2
181        yc = (y1 + y2) / 2
182
183        return (xc, yc)
184
185    @property
186    def corners(self):
187        """
188        Return the four corners of the bounding box.
189
190        Returns:
191            tuple: The four corners of the bounding box.
192        """
193        return (self.northwest, self.southwest, self.southeast, self.northeast)
194
195    @property
196    def diamond(self):
197        """
198        Return the four center points of the bounding box in a diamond shape.
199
200        Returns:
201            tuple: The four center points of the bounding box in a diamond shape.
202        """
203        return (self.north, self.west, self.south, self.east)
204
205    @property
206    def all_anchors(self):
207        """
208        Return all anchors of the bounding box.
209
210        Returns:
211            tuple: All anchors of the bounding box.
212        """
213        return (
214            self.northwest,
215            self.west,
216            self.southwest,
217            self.south,
218            self.northeast,
219            self.east,
220            self.northeast,
221            self.north,
222            self.midpoint,
223        )
224
225    @property
226    def width(self):
227        """
228        Return the width of the bounding box.
229
230        Returns:
231            float: The width of the bounding box.
232        """
233        return distance(self.northwest, self.northeast)
234
235    @property
236    def height(self):
237        """
238        Return the height of the bounding box.
239
240        Returns:
241            float: The height of the bounding box.
242        """
243        return distance(self.northwest, self.southwest)
244
245    @property
246    def size(self):
247        """
248        Return the size of the bounding box.
249
250        Returns:
251            tuple: The size of the bounding box.
252        """
253        return (self.width, self.height)
254
255    @property
256    def west(self):
257        """
258        Return the left edge midpoint.
259
260        Returns:
261            tuple: The left edge midpoint.
262        """
263        return mid_point(*self.left)
264
265    @property
266    def south(self):
267        """
268        Return the bottom edge midpoint.
269
270        Returns:
271            tuple: The bottom edge midpoint.
272        """
273        return mid_point(*self.bottom)
274
275    @property
276    def east(self):
277        """
278        Return the right edge midpoint.
279
280        Returns:
281            tuple: The right edge midpoint.
282        """
283        return mid_point(*self.right)
284
285    @property
286    def north(self):
287        """
288        Return the top edge midpoint.
289
290        Returns:
291            tuple: The top edge midpoint.
292        """
293        return mid_point(*self.top)
294
295    @property
296    def northwest(self):
297        """
298        Return the top left corner.
299
300        Returns:
301            tuple: The top left corner.
302        """
303        return self.__dict__["northwest"]
304
305    @property
306    def northeast(self):
307        """
308        Return the top right corner.
309
310        Returns:
311            tuple: The top right corner.
312        """
313        return self.__dict__["northeast"]
314
315    @property
316    def southwest(self):
317        """
318        Return the bottom left corner.
319
320        Returns:
321            tuple: The bottom left corner.
322        """
323        return self.__dict__["southwest"]
324
325    @property
326    def southeast(self):
327        """
328        Return the bottom right corner.
329
330        Returns:
331            tuple: The bottom right corner.
332        """
333        return self.__dict__["southeast"]
334
335    @property
336    def diagonal1(self):
337        """
338        Return the first diagonal. From the top left to the bottom right.
339
340        Returns:
341            tuple: The first diagonal.
342        """
343        return (self.southwest, self.northeast)
344
345    @property
346    def diagonal2(self):
347        """
348        Return the second diagonal. From the top right to the bottom left.
349
350        Returns:
351            tuple: The second diagonal.
352        """
353        return (self.southeast, self.northwest)
354
355    def get_inflated_b_box(
356        self, left_margin=None, bottom_margin=None, right_margin=None, top_margin=None
357    ):
358        """
359        Return a bounding box with offset edges.
360
361        Args:
362            left_margin (float, optional): The left margin.
363            bottom_margin (float, optional): The bottom margin.
364            right_margin (float, optional): The right margin.
365            top_margin (float, optional): The top margin.
366
367        Returns:
368            BoundingBox: The inflated bounding box.
369        """
370
371        if bottom_margin is None:
372            bottom_margin = left_margin
373        if right_margin is None:
374            right_margin = left_margin
375        if top_margin is None:
376            top_margin = bottom_margin
377
378        x, y = self.southwest[:2]
379        southwest = (x - left_margin, y - bottom_margin)
380
381        x, y = self.northeast[:2]
382        northeast = (x + right_margin, y + top_margin)
383
384        return BoundingBox(southwest, northeast)
385
386    def offset_line(self, side, offset):
387        """
388        Offset is applied outwards. Use negative values for inward offset.
389
390        Args:
391            side (Side): The side to offset.
392            offset (float): The offset distance.
393
394        Returns:
395            tuple: The offset line.
396        """
397        if isinstance(side, str):
398            side = Side[side.upper()]
399
400        if side == Side.RIGHT:
401            x1, y1 = self.southeast
402            x2, y2 = self.northeast
403            res = ((x1 + offset, y1), (x2 + offset, y2))
404        elif side == Side.LEFT:
405            x1, y1 = self.southwest
406            x2, y2 = self.northwest
407            res = ((x1 - offset, y1), (x2 - offset, y2))
408        elif side == Side.TOP:
409            x1, y1 = self.northwest
410            x2, y2 = self.northeast
411            res = ((x1, y1 + offset), (x2, y2 + offset))
412        elif side == Side.BOTTOM:
413            x1, y1 = self.southwest
414            x2, y2 = self.southeast
415            res = ((x1, y1 - offset), (x2, y2 - offset))
416        elif side == Side.DIAGONAL1:
417            res = offset_line(self.diagonal1, offset)
418        elif side == Side.DIAGONAL2:
419            res = offset_line(self.diagonal2, offset)
420        elif side == Side.H_CENTERLINE:
421            res = offset_line(self.horiz_center_line, offset)
422        elif side == Side.V_CENTERLINE:
423            res = offset_line(self.vert_center_line, offset)
424        else:
425            raise ValueError(f"Unknown side: {side}")
426            res = None
427
428        return res
429
430    def offset_point(self, anchor, dx, dy):
431        """
432        Return an offset point from the given corner.
433
434        Args:
435            anchor (Anchor): The anchor point.
436            dx (float): The x offset.
437            dy (float): The y offset.
438
439        Returns:
440            list: The offset point.
441        """
442        if isinstance(anchor, str):
443            anchor = Anchor[anchor.upper()]
444            x, y = getattr(self, anchor.value)[:2]
445        elif isinstance(anchor, Anchor):
446            x, y = anchor.value[:2]
447        else:
448            raise ValueError(f"Unknown anchor: {anchor}")
449        return [x + dx, y + dy]
450
451
452    def centered(self, item:'Union[Shape, Batch]', dx:float = 0, dy:float = 0)->Point:
453        """
454        Get the center of the reference item.
455
456        Args:
457            item (object): The reference item. Shape or Batch.
458            dx (float): The x offset.
459            dy (float): The y offset.
460
461        Returns:
462            Point: The item.midpoint of the reference item's bounding-box.
463        """
464
465        x, y = item.midpoint
466        x += dx
467        y += dy
468        return x, y
469
470    def left_of(self, item:'Union[Shape, Batch]', dx:float = 0, dy:float = 0)->Point:
471        """
472        Get the item.west of the reference item.
473
474        Args:
475            item (object): The reference item. Shape or Batch.
476            dx (float): The x offset.
477            dy (float): The y offset.
478
479        Returns:
480            Point: The item.west of the reference item's bounding-box.
481        """
482        x, y = item.west
483        w2 = self.width / 2
484        x += (dx - w2)
485        y += dy
486        return x, y
487
488    def right_of(self, item:'Union[Shape, Batch]', dx:float = 0, dy:float = 0)->Point:
489        """
490        Get the item.east of the reference item.
491
492        Args:
493            item (object): The reference item. Shape or Batch.
494            dx (float): The x offset.
495            dy (float): The y offset.
496
497        Returns:
498            Point: The item.east of the reference item's bounding-box.
499        """
500        x, y = item.east
501        w2 = self.width / 2
502        x += (dx + w2)
503        y += dy
504        return x, y
505
506    def above(self, item:'Union[Shape, Batch]', dx:float = 0, dy:float = 0)->Point:
507        """
508        Get the item.north of the reference item.
509
510        Args:
511            item (object): The reference item. Shape or Batch.
512            dx (float): The x offset.
513            dy (float): The y offset.
514
515        Returns:
516            Point: The item.north of the reference item's bounding-box.
517        """
518        x, y = item.north
519        h2 = self.height / 2
520        x += dx
521        y += (dy + h2)
522        return x, y
523
524    def below(self, item:'Union[Shape, Batch]', dx:float = 0, dy:float = 0)->Point:
525        """
526        Get the item.south of the reference item.
527
528        Args:
529            item (object): The reference item. Shape or Batch.
530            dx (float): The x offset.
531            dy (float): The y offset.
532
533        Returns:
534            Point: The item.south of the reference item's bounding-box.
535        """
536        x, y = item.south
537        h2 = self.height / 2
538        x += dx
539        y += (dy - h2)
540        return x, y
541
542    def above_left(self, item:'Union[Shape, Batch]', dx:float = 0, dy:float = 0)->Point:
543        """
544        Get the item.northwest of the reference item.
545
546        Args:
547            item (object): The reference item. Shape or Batch.
548            dx (float): The x offset.
549            dy (float): The y offset.
550
551        Returns:
552            Point: The item.northwest of the reference item's bounding-box.
553        """
554        x, y = item.northwest
555        w2 = self.width / 2
556        h2 = self.height / 2
557        x += (dx - w2)
558        y += (dy + h2)
559
560        return x, y
561
562
563    def above_right(self, item:'Union[Shape, Batch]', dx:float = 0, dy:float = 0)->Point:
564        """
565        Get the item.northeast of the reference item.
566
567        Args:
568            item (object): The reference item. Shape or Batch.
569            dx (float): The x offset.
570            dy (float): The y offset.
571
572        Returns:
573            Point: The item.northeast of the reference item's bounding-box.
574        """
575        x, y = item.northeast
576        w2 = self.width / 2
577        h2 = self.height / 2
578        x += (dx + w2)
579        y += (dy + h2)
580
581        return x, y
582
583
584    def below_left(self, item:'Union[Shape, Batch]', dx:float = 0, dy:float = 0)->Point:
585        """
586        Get the item.southwest of the reference item.
587
588        Args:
589            item (object): The reference item. Shape or Batch.
590            dx (float): The x offset.
591            dy (float): The y offset.
592
593        Returns:
594            Point: The item.southwest of the reference item's bounding-box.
595        """
596        x, y = item.southwest
597        w2 = self.width / 2
598        h2 = self.height / 2
599        x += (dx - w2)
600        y += (dy - h2)
601
602        return x, y
603
604
605    def below_right(self, item:'Union[Shape, Batch]', dx:float = 0, dy:float = 0)->Point:
606        """
607        Get the item.southeast of the reference item.
608
609        Args:
610            item (object): The reference item. Shape or Batch.
611            dx (float): The x offset.
612            dy (float): The y offset.
613
614        Returns:
615            Point: The item.southeast of the reference item's bounding-box.
616        """
617        x, y = item.southeast
618        w2 = self.width / 2
619        h2 = self.height / 2
620        x += (dx + w2)
621        y += (dy - h2)
622
623        return x, y
624
625
626    def polar_pos(self, item:'Union[Shape, Batch]', theta:float, radius:float)->Point:
627        """
628        Get the polar position of the reference item.
629
630        Args:
631            item (object): The reference item. Shape or Batch.
632            theta (float): The angle in radians.
633            radius (float): The radius.
634
635        Returns:
636            Point: The polar position of the reference item.
637        """
638
639        x, y = item.midpoint
640
641        x1, y1 = polar_to_cartesian(radius, theta)
642        x += x1
643        y += y1
644
645        return x, y
646
647
648def bounding_box(points):
649    """
650    Given a list of (x, y) points return the corresponding BoundingBox object.
651
652    Args:
653        points (list): The list of points.
654
655    Returns:
656        BoundingBox: The corresponding BoundingBox object.
657
658    Raises:
659        ValueError: If the list of points is empty.
660    """
661    if isinstance(points, np.ndarray):
662        points = points[:, :2]
663    else:
664        points = np.array(points)  # numpy array of points
665    n_points = len(points)
666    BB_EPSILON = defaults["BB_EPSILON"]
667    if n_points == 0:  # empty list of points
668        raise ValueError("Empty list of points")
669
670    if len(points.shape) == 1:
671        # single point
672        min_x, min_y = points
673        max_x = min_x + BB_EPSILON
674        max_y = min_y + BB_EPSILON
675    else:
676        # find minimum and maximum coordinates
677        min_x, min_y = points.min(axis=0)
678        max_x, max_y = points.max(axis=0)
679        if min_x == max_x:  # this could be a vertical line or degenerate points
680            max_x += BB_EPSILON
681        if min_y == max_y:  # this could be a horizontal line or degenerate points
682            max_y += BB_EPSILON
683    # bounding box corners
684    bottom_left = (min_x, min_y)
685    top_right = (max_x, max_y)
686    return BoundingBox(southwest=bottom_left, northeast=top_right)