Merge pull request #1177 from compas-dev/origin/fix_halfface_plane

Fix halfface _plane

Author: romanarust

CHANGELOG.md

@@ -204,6 +204,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * Fixed bug in `compas.datastructures.Mesh.insert_vertex`.
 * Fixed bug in `compas.geometry.angle_vectors_signed`.
 * Changed `compas.artists.MeshArtist` default colors.
+* Changed internal _plane storage of the `compas.datastructures.Halfface` from `_plane[u][v][w]` to `_plane[u][v][fkey]`
 
 ### Removed
 

src/compas/datastructures/halfface/halfface.py

@@ -13,6 +13,12 @@
 from compas.utilities import pairwise
 
 
+def iter_edges_from_vertices(vertices):
+    for i, u in enumerate(vertices):
+        j = (i + 1) % len(vertices)
+        yield u, vertices[j]
+
+
 class HalfFace(Datastructure):
     """Base half-face data structure for representing volumetric meshes.
 
@@ -474,22 +480,14 @@ def add_halfface(self, vertices, fkey=None, attr_dict=None, **kwattr):
         self._halfface[fkey] = vertices
         for name, value in attr.items():
             self.face_attribute(fkey, name, value)
-        for i in range(-2, len(vertices) - 2):
-            u = vertices[i]
-            v = vertices[i + 1]
-            w = vertices[i + 2]
-            if u == v or v == w:
-                continue
-            self.add_vertex(key=u)
-            self.add_vertex(key=v)
-            self.add_vertex(key=w)
+        for u, v in iter_edges_from_vertices(vertices):
             if v not in self._plane[u]:
                 self._plane[u][v] = {}
-            self._plane[u][v][w] = None
-            if v not in self._plane[w]:
-                self._plane[w][v] = {}
-            if u not in self._plane[w][v]:
-                self._plane[w][v][u] = None
+            self._plane[u][v][fkey] = None
+            if u not in self._plane[v]:
+                self._plane[v][u] = {}
+            self._plane[v][u][fkey] = None
+
         return fkey
 
     def add_cell(self, faces, ckey=None, attr_dict=None, **kwattr):
@@ -543,14 +541,12 @@ def add_cell(self, faces, ckey=None, attr_dict=None, **kwattr):
         for vertices in faces:
             fkey = self.add_halfface(vertices)
             vertices = self.halfface_vertices(fkey)
-            for i in range(-2, len(vertices) - 2):
-                u = vertices[i]
-                v = vertices[i + 1]
-                w = vertices[i + 2]
+            for u, v in iter_edges_from_vertices(vertices):
                 if u not in self._cell[ckey]:
                     self._cell[ckey][u] = {}
-                self._plane[u][v][w] = ckey
+                self._plane[u][v][fkey] = ckey
                 self._cell[ckey][u][v] = fkey
+
         return ckey
 
     # --------------------------------------------------------------------------
@@ -608,14 +604,11 @@ def delete_cell(self, cell):
                 del self._vertex[vertex]
         for face in cell_faces:
             vertices = self.halfface_vertices(face)
-            for i in range(-2, len(vertices) - 2):
-                u = vertices[i]
-                v = vertices[i + 1]
-                w = vertices[i + 2]
-                self._plane[u][v][w] = None
-                if self._plane[w][v][u] is None:
-                    del self._plane[u][v][w]
-                    del self._plane[w][v][u]
+            for u, v in iter_edges_from_vertices(vertices):
+                self._plane[u][v][face] = None
+                if self._plane[v][u][face] is None:
+                    del self._plane[u][v][face]
+                    del self._plane[v][u][face]
             del self._halfface[face]
             key = "-".join(map(str, sorted(vertices)))
             if key in self._face_data:
@@ -2473,10 +2466,9 @@ def edge_halffaces(self, edge):
                 halfface = self._cell[cell][v][u]
                 if self.is_halfface_on_boundary(halfface):
                     break
-        for i in range(len(cells)):
+        for _ in cells:
             halfface = self._cell[cell][u][v]
-            w = self.halfface_vertex_descendent(halfface, v)
-            cell = self._plane[w][v][u]
+            cell = self._plane[v][u][halfface]
             halffaces.append(halfface)
         return halffaces
 
@@ -2612,8 +2604,8 @@ def halfface_cell(self, halfface):
         :meth:`halfface_opposite_cell`
 
         """
-        u, v, w = self._halfface[halfface][0:3]
-        return self._plane[u][v][w]
+        u, v = self._halfface[halfface][:2]
+        return self._plane[u][v][halfface]
 
     def halfface_opposite_cell(self, halfface):
         """The cell to which the opposite halfface belongs to.
@@ -2633,8 +2625,8 @@ def halfface_opposite_cell(self, halfface):
         :meth:`halfface_cell`
 
         """
-        u, v, w = self._halfface[halfface][0:3]
-        return self._plane[w][v][u]
+        u, v = self._halfface[halfface][:2]
+        return self._plane[v][u][halfface]
 
     def halfface_opposite_halfface(self, halfface):
         """The opposite face of a face.
@@ -2659,11 +2651,9 @@ def halfface_opposite_halfface(self, halfface):
         For a boundary face, the opposite face is None.
 
         """
-        u, v, w = self._halfface[halfface][0:3]
-        nbr = self._plane[w][v][u]
-        if nbr is None:
-            return None
-        return self._cell[nbr][v][u]
+        u, v = self._halfface[halfface][:2]
+        nbr = self._plane[v][u][halfface]
+        return None if nbr is None else self._cell[nbr][v][u]
 
     def halfface_adjacent_halfface(self, halfface, halfedge):
         """Return the halfface adjacent to the halfface across the halfedge.
@@ -2693,11 +2683,8 @@ def halfface_adjacent_halfface(self, halfface, halfedge):
         u, v = halfedge
         cell = self.halfface_cell(halfface)
         nbr_halfface = self._cell[cell][v][u]
-        w = self.halfface_vertex_ancestor(nbr_halfface, v)
-        nbr_cell = self._plane[u][v][w]
-        if nbr_cell is None:
-            return None
-        return self._cell[nbr_cell][v][u]
+        nbr_cell = self._plane[u][v][nbr_halfface]
+        return None if nbr_cell is None else self._cell[nbr_cell][v][u]
 
     def halfface_vertex_ancestor(self, halfface, vertex):
         """Return the vertex before the specified vertex in a specific face.
@@ -2783,8 +2770,7 @@ def halfface_manifold_neighbors(self, halfface):
         cell = self.halfface_cell(halfface)
         for u, v in self.halfface_halfedges(halfface):
             nbr_halfface = self._cell[cell][v][u]
-            w = self.halfface_vertex_ancestor(nbr_halfface, v)
-            nbr_cell = self._plane[u][v][w]
+            nbr_cell = self._plane[u][v][nbr_halfface]
             if nbr_cell is not None:
                 nbr = self._cell[nbr_cell][v][u]
                 nbrs.append(nbr)
@@ -2843,8 +2829,8 @@ def is_halfface_on_boundary(self, halfface):
         :meth:`is_vertex_on_boundary`, :meth:`is_edge_on_boundary`, :meth:`is_cell_on_boundary`
 
         """
-        u, v, w = self._halfface[halfface][0:3]
-        return self._plane[w][v][u] is None
+        u, v = self._halfface[halfface][:2]
+        return self._plane[v][u][halfface] is None
 
     # --------------------------------------------------------------------------
     # Cell topology

tests/compas/datastructures/test_halfface.py

@@ -175,7 +175,7 @@ def test_edges_where_predicate():
 
 def test_faces_where():
     hf = HalfFace(default_face_attributes={"a": 1, "b": 2})
-    for vkey in range(4):
+    for vkey in range(5):
         hf.add_vertex(vkey)
     for i in range(3):
         hf.add_halfface([i, i + 1, i + 2])
@@ -185,7 +185,7 @@ def test_faces_where():
 
 def test_faces_where_predicate():
     hf = HalfFace(default_face_attributes={"a": 1, "b": 2})
-    for vkey in range(4):
+    for vkey in range(5):
         hf.add_vertex(vkey)
     for i in range(3):
         hf.add_halfface([i, i + 1, i + 2])
@@ -200,7 +200,7 @@ def test_faces_where_predicate():
 
 def test_cells_where():
     hf = HalfFace(default_cell_attributes={"a": 1, "b": 2})
-    for vkey in range(5):
+    for vkey in range(6):
         hf.add_vertex(vkey)
     for i in range(3):
         hf.add_cell(
@@ -217,7 +217,7 @@ def test_cells_where():
 
 def test_cells_where_predicate():
     hf = HalfFace(default_cell_attributes={"a": 1, "b": 2})
-    for vkey in range(5):
+    for vkey in range(6):
         hf.add_vertex(vkey)
     for i in range(3):
         hf.add_cell(