Merge pull request #923 from compas-dev/fix-mesh-strip-and-loop

Fix bug in continuous loops and strips

Author: tomvanmele

CHANGELOG.md

@@ -9,11 +9,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+* Added halfedge loops in `compas.datastructures.Halfedge.halfedge_loop`.
+* Added halfedge strips in `compas.datastructures.Halfedge.halfedge_strip`.
 * Added boundingbox to `compas_rhino.conduits.BaseConduit`
 
 ### Changed
 
 * Fixed bug in combination of `compas_rhino.artists.MeshArtist.draw_mesh` and `compas_rhino.utilities.drawing.draw_mesh`.
+* Fixed bug in continuous loops in `compas.datastructures.Halfedge.edge_loop`.
+* Fixed bug in continuous strips in `compas.datastructures.Halfedge.edge_strip`.
 * Changed abstract method `compas.artists.MeshArtist.draw_mesh` to implemented method in `compas_plotters.artists.MeshArtist.draw_mesh`.
 
 ### Removed

src/compas/datastructures/halfedge/halfedge.py

@@ -2092,76 +2092,75 @@ def edge_loop(self, edge):
         list of tuple of int
             The edges on the same loop as the given edge.
         """
-        if self.is_edge_on_boundary(*edge):
-            return self._edge_loop_on_boundary(edge)
-        edges = []
-        current, previous = edge
-        edges.append((previous, current))
+        u, v = edge
+        uv_loop = self.halfedge_loop((u, v))
+        if uv_loop[0][0] == uv_loop[-1][1]:
+            return uv_loop
+        vu_loop = self.halfedge_loop((v, u))
+        vu_loop[:] = [(u, v) for v, u in vu_loop[::-1]]
+        return vu_loop + uv_loop[1:]
+
+    def halfedge_loop(self, edge):
+        """Find all edges on the same loop as the halfedge, in the direction of the halfedge.
+
+        Parameters
+        ----------
+        edge : tuple of int
+            The identifier of the starting edge.
+
+        Returns
+        -------
+        list of tuple of int
+            The edges on the same loop as the given edge.
+        """
+        u, v = edge
+        if self.is_edge_on_boundary(u, v):
+            return self._halfedge_loop_on_boundary(edge)
+        edges = [(u, v)]
         while True:
-            if current == edge[1]:
-                break
-            nbrs = self.vertex_neighbors(current, ordered=True)
+            nbrs = self.vertex_neighbors(v, ordered=True)
             if len(nbrs) != 4:
                 break
-            i = nbrs.index(previous)
-            previous = current
-            current = nbrs[i - 2]
-            edges.append((previous, current))
-        edges[:] = [(u, v) for v, u in edges[::-1]]
-        if edges[0][0] == edges[-1][1]:
-            return edges
-        previous, current = edge
-        while True:
-            nbrs = self.vertex_neighbors(current, ordered=True)
-            if len(nbrs) != 4:
+            i = nbrs.index(u)
+            u = v
+            v = nbrs[i - 2]
+            edges.append((u, v))
+            if v == edges[0][0]:
                 break
-            i = nbrs.index(previous)
-            previous = current
-            current = nbrs[i - 2]
-            edges.append((previous, current))
         return edges
 
-    def _edge_loop_on_boundary(self, uv):
-        """Find all edges on the same loop as a given edge on the boundary."""
-        edges = []
-        current, previous = uv
-        edges.append((previous, current))
+    def _halfedge_loop_on_boundary(self, edge):
+        """Find all edges on the same loop as the halfedge, in the direction of the halfedge, if the halfedge is on the boundary.
+
+        Parameters
+        ----------
+        edge : tuple of int
+            The identifier of the starting edge.
+
+        Returns
+        -------
+        list of tuple of int
+            The edges on the same loop as the given edge.
+        """
+        u, v = edge
+        edges = [(u, v)]
         while True:
-            if current == uv[1]:
-                break
-            nbrs = self.vertex_neighbors(current)
+            nbrs = self.vertex_neighbors(v)
             if len(nbrs) == 2:
                 break
             nbr = None
             for temp in nbrs:
-                if temp == previous:
+                if temp == u:
                     continue
-                if self.is_edge_on_boundary(current, temp):
+                if self.is_edge_on_boundary(v, temp):
                     nbr = temp
                     break
             if nbr is None:
                 break
-            previous, current = current, nbr
-            edges.append((previous, current))
-        edges[:] = [(u, v) for v, u in edges[::-1]]
-        if edges[0][0] == edges[-1][1]:
-            return edges
-        previous, current = uv
-        while True:
-            nbrs = self.vertex_neighbors(current)
-            if len(nbrs) == 2:
-                break
-            nbr = None
-            for temp in nbrs:
-                if temp == previous:
-                    continue
-                if self.is_edge_on_boundary(current, temp):
-                    nbr = temp
-                    break
-            if nbr is None:
+            u, v = v, nbr
+            edges.append((u, v))
+            if v == edges[0][0]:
                 break
-            previous, current = current, nbr
-            edges.append((previous, current))
         return edges
 
     def edge_strip(self, edge):
@@ -2177,33 +2176,18 @@ def edge_strip(self, edge):
         list of tuple of int
             The edges on the same strip as the given edge.
         """
-        edges = []
-        v, u = edge
-        while True:
-            edges.append((u, v))
-            face = self.halfedge[u][v]
-            if face is None:
-                break
-            vertices = self.face_vertices(face)
-            if len(vertices) != 4:
-                break
-            i = vertices.index(u)
-            u = vertices[i - 1]
-            v = vertices[i - 2]
-        edges[:] = [(u, v) for v, u in edges[::-1]]
         u, v = edge
-        while True:
-            face = self.halfedge[u][v]
-            if face is None:
-                break
-            vertices = self.face_vertices(face)
-            if len(vertices) != 4:
-                break
-            i = vertices.index(u)
-            u = vertices[i - 1]
-            v = vertices[i - 2]
-            edges.append((u, v))
-        return edges
+        if self.halfedge[v][u] is None:
+            return self.halfedge_strip((u, v))
+        if self.halfedge[u][v] is None:
+            edges = self.halfedge_strip((v, u))
+            return [(u, v) for v, u in edges[::-1]]
+        vu_strip = self.halfedge_strip((v, u))
+        vu_strip[:] = [(u, v) for v, u in vu_strip[::-1]]
+        if vu_strip[0] == vu_strip[-1]:
+            return vu_strip
+        uv_strip = self.halfedge_strip((u, v))
+        return vu_strip[:-1] + uv_strip
 
     def halfedge_strip(self, edge):
         """Find all edges on the same strip as a given halfedge.
@@ -2231,6 +2215,8 @@ def halfedge_strip(self, edge):
             u = vertices[i - 1]
             v = vertices[i - 2]
             edges.append((u, v))
+            if (u, v) == edge:
+                break
         return edges
 
     # --------------------------------------------------------------------------

src/compas/datastructures/mesh/mesh.py

@@ -35,7 +35,6 @@
 from compas.geometry import vector_average
 
 from compas.utilities import linspace
-from compas.utilities import meshgrid
 
 from compas.utilities import geometric_key
 from compas.utilities import pairwise
@@ -639,16 +638,15 @@ def from_meshgrid(cls, dx, nx, dy=None, ny=None):
         dy = dy or dx
         ny = ny or nx
 
-        U, V = meshgrid(linspace(0, dx, nx + 1), linspace(0, dy, ny + 1), indexing='ij')
-
-        quads = [[
-            [U[i + 0][j + 0], V[i + 0][j + 0], 0.0],
-            [U[i + 0][j + 1], V[i + 0][j + 1], 0.0],
-            [U[i + 1][j + 1], V[i + 1][j + 1], 0.0],
-            [U[i + 1][j + 0], V[i + 1][j + 0], 0.0]
+        vertices = [[x, y, 0.0] for x, y in product(linspace(0, dx, nx + 1), linspace(0, dy, ny + 1))]
+        faces = [[
+            i * (ny + 1) + j,
+            (i + 1) * (ny + 1) + j,
+            (i + 1) * (ny + 1) + j + 1,
+            i * (ny + 1) + j + 1
         ] for i, j in product(range(nx), range(ny))]
 
-        return cls.from_polygons(quads)
+        return cls.from_vertices_and_faces(vertices, faces)
 
     # --------------------------------------------------------------------------
     # helpers

tests/compas/datastructures/test_halfedge.py

@@ -1,7 +1,12 @@
 import pytest
+import random
 
 import compas
+
+from compas.geometry import Sphere
+
 from compas.datastructures import HalfEdge
+from compas.datastructures import Mesh
 
 
 # ==============================================================================
@@ -35,6 +40,19 @@ def edge_key():
     return (0, 1)
 
 
+@pytest.fixture
+def sphere():
+    sphere = Sphere([0, 0, 0], 1.0)
+    mesh = Mesh.from_shape(sphere, u=16, v=16)
+    return mesh
+
+
+@pytest.fixture
+def grid():
+    mesh = Mesh.from_meshgrid(dx=10, nx=10)
+    return mesh
+
+
 # ==============================================================================
 # Tests - Schema & jsonschema
 # ==============================================================================
@@ -240,3 +258,103 @@ def test_del_edge_attribute_in_view(mesh, edge_key):
     del attrs["foo"]
     with pytest.raises(KeyError):
         attrs["foo"]
+
+
+# ==============================================================================
+# Tests - Loops & Strip
+# ==============================================================================
+
+def test_loops_and_strips_closed(sphere):
+    poles = list(sphere.vertices_where({'vertex_degree': 16}))
+
+    for nbr in sphere.vertex_neighbors(poles[0]):
+        meridian = sphere.edge_loop((poles[0], nbr))
+
+        assert len(meridian) == 16, meridian
+        assert meridian[0][0] == poles[0]
+        assert meridian[-1][1] == poles[1]
+
+        for edge in meridian[1:-1]:
+            strip = sphere.edge_strip(edge)
+
+            assert len(strip) == 17, strip
+            assert strip[0] == strip[-1]
+
+        for edge in meridian[1:-1]:
+            ring = sphere.edge_loop(sphere.halfedge_before(*edge))
+
+            assert len(ring) == 16, ring
+            assert ring[0][0] == ring[-1][1]
+
+
+def test_loops_and_strips_open(grid):
+    assert grid.number_of_edges() == 220
+
+    edge = 47, 48
+    strip = grid.edge_strip(edge)
+    loop = grid.edge_loop(edge)
+
+    assert edge in strip
+    assert len(strip) == 11
+    assert grid.is_edge_on_boundary(* strip[0])
+    assert grid.is_edge_on_boundary(* strip[-1])
+
+    assert edge in loop
+    assert len(loop) == 10
+    assert grid.is_vertex_on_boundary(loop[0][0])
+    assert grid.is_vertex_on_boundary(loop[-1][1])
+
+
+def test_loops_and_strips_open_corner(grid):
+    assert grid.number_of_edges() == 220
+
+    edge = 0, 1
+    loop = grid.edge_loop(edge)
+    strip = grid.edge_strip(edge)
+
+    assert edge in strip
+    assert len(strip) == 11
+    assert grid.is_edge_on_boundary(* strip[0])
+    assert grid.is_edge_on_boundary(* strip[-1])
+    assert edge == strip[-1]
+
+    assert edge in loop
+    assert len(loop) == 10
+    assert edge == loop[0]
+
+    edge = 1, 0
+    loop = grid.edge_loop(edge)
+    strip = grid.edge_strip(edge)
+
+    assert edge in strip
+    assert len(strip) == 11
+    assert grid.is_edge_on_boundary(* strip[0])
+    assert grid.is_edge_on_boundary(* strip[-1])
+    assert edge == strip[0]
+
+    assert edge in loop
+    assert len(loop) == 10
+    assert edge == loop[-1]
+
+
+def test_loops_and_strips_open_boundary(grid):
+    assert grid.number_of_edges() == 220
+
+    edge = random.choice(grid.edges_on_boundary())
+    u, v = edge
+
+    loop = grid.edge_loop(edge)
+    strip = grid.edge_strip(edge)
+    
+    assert edge in strip
+    assert len(strip) == 11
+    assert grid.is_edge_on_boundary(* strip[0])
+    assert grid.is_edge_on_boundary(* strip[-1])
+
+    assert edge in loop
+    assert len(loop) == 10
+
+    if grid.halfedge[u][v] is None:
+        assert edge == strip[-1]
+    else:
+        assert edge == strip[0]