Improve test coverage

Author: ArzhelaR

environment/actions/triangular_actions.py

@@ -79,8 +79,6 @@ def flip_edge(mesh_analysis, n1: Node, n2: Node) -> True:
 
     after_check = check_mesh(mesh_analysis, mesh_before)
     if not after_check:
-        plot_mesh(mesh_before)
-        plot_mesh(mesh_analysis.mesh)
         raise ValueError("Some checks are missing")
 
     return valid_action, topo, geo
@@ -242,23 +240,21 @@ def collapse_edge(mesh_analysis, n1: Node, n2: Node) -> True:
                     ds = ds11.get_beta(2)
                     if i > 30:
                         i = 0
-                        plot_mesh(mesh_analysis.mesh)
                         raise ValueError("Potential infinite loop in action collapse")
             else:
                 ds = d2s.get_beta(1)
                 ds.set_node(n1)
                 ds1 = ds.get_beta(1)
             if i > 30:
                 i = 0
-                plot_mesh(mesh_analysis.mesh)
                 raise ValueError("Potential infinite loop in action collapse")
 
         found, new_x, new_y = mesh_analysis.find_star_vertex(n1)
         if found:
             n1.set_xy(new_x, new_y)
         else:
-            plot_mesh(mesh_before)
-            plot_mesh(mesh_analysis.mesh)
+            # plot_mesh(mesh_before)
+            # plot_mesh(mesh_analysis.mesh)
             mesh_analysis.find_star_vertex(n1, plot=True)
             raise ValueError("No star vertex found")
 
@@ -301,7 +297,7 @@ def collapse_edge(mesh_analysis, n1: Node, n2: Node) -> True:
 
     after_check = check_mesh(mesh_analysis, mesh_before)
     if not after_check:
-        mesh_analysis.is_star_vertex(n1, np.array([n1.x(), n1.y()]), True)
+        # mesh_analysis.is_star_vertex(n1, np.array([n1.x(), n1.y()]), True)
         raise ValueError("Some checks are missing")
     return True, topo, geo
 
@@ -352,54 +348,54 @@ def check_mesh(mesh_analysis, m=None) -> bool:
             return False
     return True
 
-
-def check_mesh_debug(mesh_analysis, mesh_before=None)->True:
-    for dart_info in mesh_analysis.mesh.active_darts():
-        #Check beta2 relation
-        d = dart_info[0]
-        d2 = dart_info[2]
-        # if associated twin dart no longer exist
-        if d2 >= 0 and mesh_analysis.mesh.dart_info[d2, 0] < 0:
-            plot_mesh(mesh_analysis.mesh)
-            if mesh_before is not None:
-                plot_mesh(mesh_before)
-            raise ValueError("error beta2")
-        # if beta2 relation is not symetrical
-        elif d2 >= 0 and mesh_analysis.mesh.dart_info[d2, 2] != d:
-            plot_mesh(mesh_analysis.mesh)
-            if mesh_before is not None:
-                plot_mesh(mesh_before)
-            raise ValueError("error beta2")
-        # null dart
-        elif d2>=0 and mesh_analysis.mesh.dart_info[d2, 3] == mesh_analysis.mesh.dart_info[d, 3]:
-            plot_mesh(mesh_analysis.mesh)
-            if mesh_before is not None:
-                plot_mesh(mesh_before)
-            raise ValueError("same node for twin darts")
-        #if adjacent face is the same
-        elif  d2>=0 and mesh_analysis.mesh.dart_info[d2, 4] == mesh_analysis.mesh.dart_info[d, 4]:
-            plot_mesh(mesh_analysis.mesh)
-            if mesh_before is not None:
-                plot_mesh(mesh_before)
-            raise ValueError("same adjacent face")
-
-
-        d1 = mesh_analysis.mesh.dart_info[d,1]
-        d11 = mesh_analysis.mesh.dart_info[d1,1]
-
-        #Check beta1
-        if  mesh_analysis.mesh.dart_info[d11,1]!=d :
-            plot_mesh(mesh_analysis.mesh)
-            if mesh_before is not None:
-                plot_mesh(mesh_before)
-            raise ValueError("error beta1")
-
-        if d2 >= 0 :
-            d = Dart(mesh_analysis.mesh, d)
-            d2, d1, d11, d21, d211, n1, n2, n3, n4 = mesh_analysis.mesh.active_triangles(d)
-
-            if len(set([n1.id, n2.id, n3.id, n4.id])) < 4:
-                plot_mesh(mesh_analysis.mesh)
-                if mesh_before is not None:
-                    plot_mesh(mesh_before)
-                raise ValueError("same traingle for two faces")
+#
+# def check_mesh_debug(mesh_analysis, mesh_before=None)->True:
+#     for dart_info in mesh_analysis.mesh.active_darts():
+#         #Check beta2 relation
+#         d = dart_info[0]
+#         d2 = dart_info[2]
+#         # if associated twin dart no longer exist
+#         if d2 >= 0 and mesh_analysis.mesh.dart_info[d2, 0] < 0:
+#             plot_mesh(mesh_analysis.mesh)
+#             if mesh_before is not None:
+#                 plot_mesh(mesh_before)
+#             raise ValueError("error beta2")
+#         # if beta2 relation is not symetrical
+#         elif d2 >= 0 and mesh_analysis.mesh.dart_info[d2, 2] != d:
+#             plot_mesh(mesh_analysis.mesh)
+#             if mesh_before is not None:
+#                 plot_mesh(mesh_before)
+#             raise ValueError("error beta2")
+#         # null dart
+#         elif d2>=0 and mesh_analysis.mesh.dart_info[d2, 3] == mesh_analysis.mesh.dart_info[d, 3]:
+#             plot_mesh(mesh_analysis.mesh)
+#             if mesh_before is not None:
+#                 plot_mesh(mesh_before)
+#             raise ValueError("same node for twin darts")
+#         #if adjacent face is the same
+#         elif  d2>=0 and mesh_analysis.mesh.dart_info[d2, 4] == mesh_analysis.mesh.dart_info[d, 4]:
+#             plot_mesh(mesh_analysis.mesh)
+#             if mesh_before is not None:
+#                 plot_mesh(mesh_before)
+#             raise ValueError("same adjacent face")
+#
+#
+#         d1 = mesh_analysis.mesh.dart_info[d,1]
+#         d11 = mesh_analysis.mesh.dart_info[d1,1]
+#
+#         #Check beta1
+#         if  mesh_analysis.mesh.dart_info[d11,1]!=d :
+#             plot_mesh(mesh_analysis.mesh)
+#             if mesh_before is not None:
+#                 plot_mesh(mesh_before)
+#             raise ValueError("error beta1")
+#
+#         if d2 >= 0 :
+#             d = Dart(mesh_analysis.mesh, d)
+#             d2, d1, d11, d21, d211, n1, n2, n3, n4 = mesh_analysis.mesh.active_triangles(d)
+#
+#             if len(set([n1.id, n2.id, n3.id, n4.id])) < 4:
+#                 plot_mesh(mesh_analysis.mesh)
+#                 if mesh_before is not None:
+#                     plot_mesh(mesh_before)
+#                 raise ValueError("same traingle for two faces")

mesh_model/mesh_analysis/global_mesh_analysis.py

@@ -59,7 +59,6 @@ def get_angle(self, d1: Dart, d2: Dart) -> float:
         angle_rad = atan2(cross, dot)
         angle = degrees(angle_rad) % 360
         if np.isnan(angle):
-            plot_mesh(self.n.mesh)
             raise ValueError("Angle error")
         return angle
 
@@ -135,8 +134,6 @@ def degree(self) -> int:
             else:
                 adjacency += 0.5
         if adjacency != int(adjacency):
-            #adjacency = int(adjacency+0.5)
-            plot_mesh(self.n.mesh)
             raise ValueError("Adjacency error")
         return adjacency
 

mesh_model/mesh_analysis/quadmesh_analysis.py

@@ -127,130 +127,6 @@ def get_dart_geometric_quality(self, d: Dart, m=None) -> int:
         else:
             raise ValueError("Quality configuration doesn't exist")
 
-    def find_star_vertex(self, n:Node, plot=False)-> (bool, float, float):
-        # Retrieve all neighboring vertices in order
-        d = n.get_dart()
-        d2 = d.get_beta(2)
-        n_start = d2.get_node()  # First neighbour to retrieve
-
-        adj_nodes = [n_start]
-        nodes_coord = [[n_start.x(), n_start.y()]]
-
-        d = d2.get_beta(1)
-        d2 = d.get_beta(2)
-        n_neighbour = d2.get_node()
-
-        # As long as we haven't returned to the first neighbor, we keep searching.
-        # This works because the collapse action is restricted to inner darts that are not connected to a boundary node.
-        # Therefore, we are guaranteed to find the first vertex by following the beta1 and beta2 relations.
-
-        while n_neighbour != n_start:
-            adj_nodes.append(n_neighbour)
-            nodes_coord.append([n_neighbour.x(), n_neighbour.y()])
-            d = d2.get_beta(1)
-            d2 = d.get_beta(2)
-            n_neighbour = d2.get_node()
-
-        nodes_coord = np.array(nodes_coord)
-
-        # Create a Polygon with shapely package
-        poly = Polygon(nodes_coord)
-
-        # If polygon is convexe
-        if poly.is_valid and poly.is_simple and poly.convex_hull.equals(poly):
-            centroid = poly.centroid
-            return True, centroid.x, centroid.y
-
-        #Else if polygon is concav, we're looking if there is a "star area"
-        p_before = None
-        p_first = None
-        star_poly = poly
-        for p in poly.exterior.coords[:-1]:
-            if p_before is not None:
-                # one side of the polygon
-                seg = LineString([p, p_before])
-
-                # we create a big quad box
-                box =  Polygon([(-1e5, 0), (1e5, 0), (1e5, 1e5), (-1e5, 1e5)])
-
-                # segment angle
-                dx = seg.coords[1][0] - seg.coords[0][0]
-                dy = seg.coords[1][1] - seg.coords[0][1]
-                angle = math.degrees(math.atan2(dy, dx))
-
-                #moving box
-                box_rot = affinity.rotate(box, angle, origin=(0, 0))
-                origin_pt = Point(seg.coords[0])
-                box_final = affinity.translate(box_rot, origin_pt.x, origin_pt.y)
-
-                star_poly = star_poly.intersection(box_final)
-                if star_poly.is_empty:
-                    plt.figure(figsize=(6, 6))
-                    # Polygone
-                    x, y = poly.exterior.xy
-                    plt.fill(x, y, alpha=0.3, edgecolor='blue',
-                             label='Polygon formed par by neighbours vertices')
-
-                    # Voisins
-                    plt.scatter(nodes_coord[:, 0], nodes_coord[:, 1], color='blue', zorder=5, label='Neighbours')
-
-                    plt.legend()
-                    plt.gca().set_aspect('equal')
-                    plt.show()
-                    return False, 0, 0
-            elif p_before is None:
-                p_first = p
-            p_before = p
-
-        #We do the same for the last segment
-        seg = LineString([p_first, p_before])
-        box = Polygon([(-1e5, 0), (1e5, 0), (1e5, 1e5), (-1e5, 1e5)])
-        dx = seg.coords[1][0] - seg.coords[0][0]
-        dy = seg.coords[1][1] - seg.coords[0][1]
-        angle = math.degrees(math.atan2(dy, dx))
-        box_rot = affinity.rotate(box, angle, origin=(0, 0))
-        origin_pt = Point(seg.coords[0])
-        box_final = affinity.translate(box_rot, origin_pt.x, origin_pt.y)
-
-        star_poly = star_poly.intersection(box_final)
-        if star_poly.is_empty:
-            plt.figure(figsize=(6, 6))
-            # Polygone
-            x, y = poly.exterior.xy
-            plt.fill(x, y, alpha=0.3, edgecolor='blue',
-                     label='Polygon formed par by neighbours vertices')
-
-            # Voisins
-            plt.scatter(nodes_coord[:, 0], nodes_coord[:, 1], color='blue', zorder=5, label='Neighbours')
-
-            plt.legend()
-            plt.gca().set_aspect('equal')
-            plt.show()
-            return False, 0, 0
-
-        if plot:
-            plt.figure(figsize=(6, 6))
-            # Polygone
-            x, y = poly.exterior.xy
-            plt.fill(x, y, alpha=0.3, edgecolor='blue',
-                     label='Polygon formed par by neighbours vertices')
-
-            # Voisins
-            plt.scatter(nodes_coord[:, 0], nodes_coord[:, 1], color='blue', zorder=5, label='Neighbours')
-
-            # Polygone
-            x_s, y_s = star_poly.exterior.xy
-            plt.fill(x_s, y_s, alpha=0.3, facecolor='lightcoral',
-                     label='Star area')
-
-            plt.legend()
-            plt.gca().set_aspect('equal')
-            plt.show()
-
-        centroid = star_poly.centroid
-        return True, centroid.x ,centroid.y
-
-
     def get_adjacent_faces(self, n: Node, d_from: Dart, d_to: Dart) -> list:
         adj_faces = []
         d2 = d_from