fix(polygon): Add method to offset polygons

Author: chriswmackey

ladybug_geometry/geometry2d/polygon.py

@@ -447,6 +447,60 @@ def scale(self, factor, origin=None):
         else:
             return Polygon2D(tuple(pt.scale(factor, origin) for pt in self.vertices))
 
+    def offset(self, distance, check_intersection=False):
+        """Offset the polygon by a given distance inwards or outwards.
+
+        Note that the resulting shape may be self-intersecting if the distance
+        is large enough and the is_self_intersecting property may be used to identify
+        these shapes.
+
+        Args:
+            distance: The distance inwards that the polygon will be offset.
+                Positive values will be offset inwards while negative ones
+                will be offset outwards.
+            check_intersection: A boolean to note whether the resulting operation
+                should be checked for self intersection and, if so, None will be
+                returned instead of the mis-shaped polygon.
+        """
+        # make sure the offset is not zero
+        if distance == 0:
+            return self
+
+        # loop through the vertices and get the new offset vectors
+        move_vecs, max_i = [], len(self._vertices) - 1
+        for i, pt in enumerate(self._vertices):
+            v1 = self._vertices[i - 1] - pt
+            end_i = i + 1 if i != max_i else 0
+            v2 = self._vertices[end_i] - pt
+            ang = v1.angle_clockwise(v2) / 2 if not self.is_clockwise \
+                else v1.angle_counterclockwise(v2) / 2
+            m_vec = v1.rotate(-ang).normalize() if not self.is_clockwise \
+                else v1.rotate(ang).normalize()
+            m_dist = distance / math.sin(ang)
+            m_vec = m_vec * m_dist
+            move_vecs.append(m_vec)
+
+        # move the vertices by the offset to create the new Polygon2D
+        new_pts = tuple(pt.move(m_vec) for pt, m_vec in zip(self._vertices, move_vecs))
+        new_poly = Polygon2D(new_pts)
+
+        # check for self intersection between the moving vectors if requested
+        if check_intersection:
+            poly_segs = new_poly.segments
+            _segs = [LineSegment2D(p, v) for p, v in zip(self._vertices, move_vecs)]
+            _skip = (0, len(_segs) - 1)
+            _other_segs = [x for j, x in enumerate(poly_segs) if j not in _skip]
+            for _oth_s in _other_segs:
+                if _segs[0].intersect_line_ray(_oth_s) is not None:  # intersection!
+                    return None
+            for i, _s in enumerate(_segs[1 : len(_segs)]):
+                _skip = (i, i + 1)
+                _other_segs = [x for j, x in enumerate(poly_segs) if j not in _skip]
+                for _oth_s in _other_segs:
+                    if _s.intersect_line_ray(_oth_s) is not None:  # intersection!
+                        return None
+        return new_poly
+
     def intersect_line_ray(self, line_ray):
         """Get the intersections between this polygon and a Ray2D or LineSegment2D.
 

ladybug_geometry/geometry3d/cone.py

@@ -109,7 +109,7 @@ def volume(self):
         return 1 / 3 * math.pi * self.radius ** 2 * self.height
 
     @property
-    def base(self): 
+    def base(self):
         """Get an Arc3D representing the circular base of the cone."""
         if self._base is None:
             plane = Plane(self.axis.reverse(), self.vertex + self.axis)

ladybug_geometry/geometry3d/face.py

@@ -605,6 +605,7 @@ def is_geometrically_equivalent(self, face, tolerance):
             face: Another face for which geometric equivalency will be tested.
             tolerance: The minimum difference between the coordinate values of two
                 vertices at which they can be considered geometrically equivalent.
+
         Returns:
             True if geometrically equivalent. False if not geometrically equivalent.
         """

ladybug_geometry/geometry3d/plane.py

@@ -57,7 +57,7 @@ def __init__(self, n=Vector3D(0, 0, 1), o=Point3D(0, 0, 0), x=None):
                 "Expected Vector3D for plane X-axis. Got {}.".format(type(x))
             x = x.normalize()
             assert abs(self._n.x * x.x + self._n.y * x.y + self._n.z * x.z) < 1e-2, \
-                'Plane X-axis and normal vector are not orthagonal. Got angle of {} ' \
+                'Plane X-axis and normal vector are not orthogonal. Got angle of {} ' \
                 'degrees between them.'.format(math.degrees(self._n.angle(x)))
             self._x = x
         self._y = self._n.cross(self._x)

ladybug_geometry/triangulation.py

@@ -10,12 +10,11 @@
 The version here is based off of the JavaScript earcut 2.1.1 release, and is
 functionally identical.
 """
-import math
 
 
 def earcut(data, hole_indices=None, dim=2):
     """Triangulate a list of vertices that make up a shape, either with or without holes.
-    
+
     Args:
         data: A flat array of vertex coordinates like [x0,y0, x1,y1, x2,y2, ...].
         hole_indices: A flat array of the starting indices for each hole. For example,
@@ -29,7 +28,7 @@ def earcut(data, hole_indices=None, dim=2):
     """
     dim = dim or 2
     hasHoles = hole_indices and len(hole_indices)
-    outerLen =  hole_indices[0] * dim if hasHoles else len(data)
+    outerLen = hole_indices[0] * dim if hasHoles else len(data)
     outerNode = _linked_list(data, 0, outerLen, dim, True)
     triangles = []
 
@@ -161,7 +160,7 @@ def _earcut_linked(ear, triangles, dim, minX, minY, size, _pass=None):
 
             _remove_node(ear)
 
-            # skipping the next vertice leads to less sliver triangles
+            # skipping the next vertex leads to less sliver triangles
             ear = next.next
             stop = next.next
 
@@ -194,7 +193,7 @@ def _is_ear(ear):
     c = ear.next
 
     if _area(a, b, c) >= 0:
-        return False # reflex, can't be an ear
+        return False  # reflex, can't be an ear
 
     # now make sure we don't have other points inside the potential ear
     p = ear.next.next
@@ -215,7 +214,7 @@ def _is_ear_hashed(ear, minX, minY, size):
     c = ear.next
 
     if _area(a, b, c) >= 0:
-        return False # reflex, can't be an ear
+        return False  # reflex, can't be an ear
 
     # triangle bbox; min & max are calculated like this for speed
     minTX = (a.x if a.x < c.x else c.x) if a.x < b.x else (b.x if b.x < c.x else c.x)
@@ -318,7 +317,7 @@ def _eliminate_holes(data, hole_indices, outerNode, dim):
 
     for i in range(len(hole_indices)):
         start = hole_indices[i] * dim
-        end =  hole_indices[i + 1] * dim if i < _len - 1 else len(data)
+        end = hole_indices[i + 1] * dim if i < _len - 1 else len(data)
         _list = _linked_list(data, start, end, dim, False)
 
         if (_list == _list.next):
@@ -338,7 +337,7 @@ def _eliminate_holes(data, hole_indices, outerNode, dim):
 
 def _eliminate_hole(hole, outerNode):
     """Find a bridge between vertices that connects hole with an outer ring.
-    
+
     Return a shape with the hole linked into it."""
     outerNode = _find_hole_bridge(hole, outerNode)
     if outerNode:
@@ -379,7 +378,7 @@ def _find_hole_bridge(hole, outerNode):
         return None
 
     if hx == qx:
-        return m.prev # hole touches outer segment; pick lower endpoint
+        return m.prev  # hole touches outer segment; pick lower endpoint
 
     # check points inside the triangle of hole point, segment intersection and endpoint
     # if there are no points found, we have a valid connection
@@ -400,7 +399,7 @@ def _find_hole_bridge(hole, outerNode):
         if hx >= p.x and p.x >= mx and \
                 _point_in_triangle(hx_or_qx, hy, mx, my, qx_or_hx, hy, p.x, p.y):
             try:
-                tan = abs(hy - p.y) / (hx - p.x) # tangential
+                tan = abs(hy - p.y) / (hx - p.x)  # tangential
             except ZeroDivisionError:
                 break
 
@@ -422,7 +421,7 @@ def _index_curve(start, minX, minY, size):
     while do or p != start:
         do = False
 
-        if p.z == None:
+        if p.z is None:
             p.z = _z_order(p.x, p.y, minX, minY, size)
 
         p.prevZ = p.prev
@@ -585,8 +584,8 @@ def _intersects_polygon(a, b):
 
     while do or p != a:
         do = False
-        if (p.i != a.i and p.next.i != a.i and p.i != b.i and p.next.i != b.i and \
-                _intersects(p, p.next, a, b)):
+        init_int = p.i != a.i and p.next.i != a.i and p.i != b.i and p.next.i != b.i
+        if init_int and _intersects(p, p.next, a, b):
             return True
 
         p = p.next
@@ -691,7 +690,7 @@ def __init__(self, i, x, y):
         self.x = x
         self.y = y
 
-        # previous and next vertice nodes in a polygon ring
+        # previous and next vertex nodes in a polygon ring
         self.prev = None
         self.next = None
 

tests/polygon2d_test.py

@@ -274,6 +274,18 @@ def test_reverse():
     assert polygon.is_self_intersecting == new_polygon.is_self_intersecting
 
 
+def test_offset():
+    """Test the offset method."""
+    pts_1 = (Point2D(0, 0), Point2D(2, 0), Point2D(2, 2), Point2D(0, 2))
+    polygon = Polygon2D(pts_1)
+    new_polygon = polygon.offset(0.5)
+
+    assert 0.99 < new_polygon.area < 1.01
+    assert not new_polygon.is_clockwise
+    assert polygon.is_convex == new_polygon.is_convex
+    assert polygon.is_self_intersecting == new_polygon.is_self_intersecting
+
+
 def test_move():
     """Test the Polygon2D move method."""
     pts = (Point2D(0, 0), Point2D(2, 0), Point2D(2, 2), Point2D(0, 2))