#25 Polygon from lists of points, CW/CCW checking

Author: rland93

src/uavfpy/planner/coverage/bdc.py

@@ -1,4 +1,3 @@
-from polyskel import polyskel
 import networkx as nx
 import numpy as np
 import copy, enum
@@ -47,7 +46,6 @@ def degree2rad(deg):
     """
     return deg * np.pi / 180
 
-
 def discretize_entire(J: nx.DiGraph, R: nx.Graph, gridsz: float):
     pts = get_points_array(J)
     xmin, xmax = np.min(pts[:, 0]), np.max(pts[:, 0])

src/uavfpy/planner/coverage/polygon.py

@@ -3,6 +3,12 @@
 import networkx as nx
 from matplotlib import pyplot as plt
 import copy
+import enum
+
+
+class ORIENTATION(enum.Enum):
+    CCW = 1
+    CW = -1
 
 
 def beta_clusters(
@@ -41,20 +47,56 @@ def dist(p1, p2):
     return points
 
 
-class RandomPolygon(object):
-    def __init__(self, n, points=None, holes=2):
-        if points is not None:
-            self.points = points
-        else:
-            self.points = beta_clusters(clusters=4, ppc=n // 4)
-
-        self.nholes = holes
-
-        self.G, self.dt, self.dt_orig = self.polygon(
-            self.points,
-            holes=holes,
-            removals=n // 3,
-        )
+def reordercw(points: np.ndarray, tobe: str):
+    """return numpy view of re-ordered points"""
+    cw = 0.0
+    for i in range(points.shape[0] - 1):
+        p1, p2 = points[i], points[i + 1]
+        cw += p2[0] * p1[1] - p1[0] * p2[1]
+    if cw >= 0 and tobe == ORIENTATION.CW:
+        return points
+    elif cw < 0 and tobe == ORIENTATION.CW:
+        print("reversing")
+        return points[::-1]
+    elif cw <= 0 and tobe == ORIENTATION.CCW:
+        return points
+    elif cw > 0 and tobe == ORIENTATION.CCW:
+        print("reversing")
+        return points[::-1]
+
+
+class Polygon(object):
+    def __init__(self, boundaries: np.ndarray, holes: list):
+        if boundaries.shape[0] < 3:
+            raise ValueError("Boundaries must have at least 3 points.")
+
+        # check orientation of inputs
+        boundaries = reordercw(boundaries, ORIENTATION.CW)
+        for i, hole in enumerate(holes):
+            holes[i] = reordercw(hole, ORIENTATION.CCW)
+
+        # create digraph from list
+        self.G = nx.DiGraph()
+        node = 0
+        # add all points
+        for i in range(boundaries.shape[0] - 1):
+            self.G.add_node(node, points=boundaries[i])
+            self.G.add_edge(node, node + 1, weight=1)
+            node += 1
+        # add edge to close the loop and add last node
+        self.G.add_node(node, points=boundaries[-1])
+        self.G.add_edge(node, 0, weight=1)
+        node += 1
+        for hole in holes:
+            hole0 = node
+            for i in range(hole.shape[0] - 1):
+                self.G.add_node(node, points=hole[i])
+                self.G.add_edge(node, node + 1, weight=2)
+                node += 1
+            # add edge to close the loop and add last node
+            self.G.add_node(node, points=hole[-1])
+            self.G.add_edge(node, hole0, weight=2)
+            node += 1
 
     def removable_interiors(self, dt: spatial.Delaunay) -> tuple:
         """find indices of interior simplices that are safe to remove in dt"""
@@ -220,12 +262,12 @@ def polygon(
                 for (e1, e2), c in zip(M.edges, cyc):
                     outer = True
                     M[e1][e2]["weight"] = 1
-                    cw += self.addcw(H, e1, e2)
+                    cw += self.addcw_h(H, e1, e2)
             else:
                 for (e1, e2), c in zip(M.edges, cyc):
                     M[e1][e2]["weight"] = 2
                     outer = False
-                    cw += self.addcw(H, e1, e2)
+                    cw += self.addcw_h(H, e1, e2)
             cw = cw >= 0
             # categorize nodes
             # append
@@ -240,7 +282,7 @@ def polygon(
         out_graph = nx.compose_all(outputgraphs)
         return out_graph, dt, dt_orig
 
-    def addcw(self, H: nx.DiGraph, e1: int, e2: int) -> float:
+    def addcw_h(self, H: nx.DiGraph, e1: int, e2: int) -> float:
         """determine which way the edge is pointing
 
         e.g.
@@ -257,9 +299,11 @@ def addcw(self, H: nx.DiGraph, e1: int, e2: int) -> float:
         p1, p2 = H.nodes[e1]["points"], H.nodes[e2]["points"]
         return (p2[0] - p1[0]) * (p2[1] + p1[1])
 
+    def cw(self, p1, p2) -> float:
+        return (p2[0] - p1[0]) * (p2[1] + p1[1])
+
     def plot(
         self,
-        G: nx.DiGraph,
         ax: plt.Axes,
         posattr: str = "points",
         arrows: bool = False,
@@ -273,14 +317,14 @@ def plot(
         draw_nodes=True,
     ) -> plt.Axes:
         """Draw a DiGraph `G` with points stored in `posattr` onto `ax`"""
-        pos = nx.get_node_attributes(G, posattr)
+        pos = nx.get_node_attributes(self.G, posattr)
         if not ecolor:
             try:
-                ecolor = [G[u][v][ecolorattr] for u, v in G.edges()]
+                ecolor = [self.G[u][v][ecolorattr] for u, v in self.G.edges()]
             except:
-                ecolor = [5 for _ in G.edges()]
+                ecolor = [5 for _ in self.G.edges()]
         nx.draw_networkx_edges(
-            G,
+            self.G,
             pos,
             ax=ax,
             node_size=4,
@@ -291,20 +335,34 @@ def plot(
         )
         if draw_nodes:
             nx.draw_networkx_nodes(
-                G,
+                self.G,
                 pos,
                 ax=ax,
                 node_shape=m,
                 node_color=nodecolor,
                 node_size=30,
             )
         if node_text:
-            for n in G.nodes:
+            for n in self.G.nodes:
                 ax.text(pos[n][0], pos[n][1], s=str(n))
         ax.autoscale(tight=False)
         return ax
 
 
+class RandomPolygon(Polygon):
+    def __init__(self, n, points=None, holes=2):
+        if points is not None:
+            self.points = points
+        else:
+            self.points = beta_clusters(clusters=4, ppc=n // 4)
+        self.nholes = holes
+        self.G, self.dt, self.dt_orig = self.polygon(
+            self.points,
+            holes=holes,
+            removals=n // 3,
+        )
+
+
 def stupid_spiky_polygon(
     R_inner: int,
     R_outer: int,

tests/coverage/test_polygon.py

@@ -1,24 +1,45 @@
 import pytest
 from uavfpy.planner.coverage import polygon
 import networkx as nx
+import numpy as np
+
+# a boundary whose points are oriented clockwise
+CW = [
+    [0.1, 0.2],
+    [0.6, 0.6],
+    [0.8, 0.1],
+    [0.3, -0.5],
+    [0.15, -0.1],
+]
+
+# a hole whose points are oriented clockwise
+CW_HOLE = [
+    [0.2, 0.2],
+    [0.4, 0.25],
+    [0.3, 0.0],
+]
+
 
 @pytest.fixture()
 def rand_poly():
-    return polygon.RandomPolygon(50, holes= 5)
+    return polygon.RandomPolygon(50, holes=5)
+
 
 def test_beta_clusters():
     npoints = 50
-    points = polygon.beta_clusters(5, ppc = npoints // 5)
+    points = polygon.beta_clusters(5, ppc=npoints // 5)
     assert points.shape[0] == npoints
     assert points.shape[1] == 2
 
+
 def test_make_rand_poly(rand_poly):
     assert isinstance(rand_poly.G, nx.DiGraph)
 
+
 def test_randpoly_properties(rand_poly):
     # planarity
     assert nx.is_planar(rand_poly.G)
-    
+
     # connectivity
     weakly_connected_parts = list(nx.weakly_connected_components(rand_poly.G))
     if rand_poly.nholes == 0:
@@ -27,4 +48,28 @@ def test_randpoly_properties(rand_poly):
         assert len(weakly_connected_parts) == rand_poly.nholes + 1
 
     # the graph contains one cycle for the outer boundary, and one cycle for each hole
-    assert len(list(nx.simple_cycles(rand_poly.G))) == rand_poly.nholes + 1
+    assert len(list(nx.simple_cycles(rand_poly.G))) == rand_poly.nholes + 1
+
+
+@pytest.fixture()
+def boundaries_cw():
+    boundaries = np.array(CW)
+    return boundaries
+
+
+@pytest.fixture()
+def boundaries_ccw():
+    boundaries = np.array(list(reversed(CW)))
+    return boundaries
+
+
+@pytest.fixture()
+def holes_cw():
+    holes = [np.array(CW_HOLE)]
+    return holes
+
+
+@pytest.fixture()
+def holes_ccw():
+    holes = [np.array(list(reversed(CW_HOLE)))]
+    return holes