New mesh analysis structure to allow only topological analysis and action validation.

There are still some issues that need to be corrected.

Author: ArzhelaR

environment/actions/smoothing.py

@@ -2,7 +2,7 @@
 
 from mesh_model.mesh_struct.mesh import Mesh
 from mesh_model.mesh_struct.mesh_elements import Node
-from mesh_model.mesh_analysis.global_mesh_analysis import adjacent_darts, on_boundary
+from mesh_model.mesh_analysis.global_mesh_analysis import GlobalMeshAnalysis
 
 def smoothing_mean(mesh: Mesh) -> True:
     for i in range (20):

environment/actions/triangular_actions.py

@@ -1,25 +1,33 @@
 from __future__ import annotations
 
-from mesh_model.mesh_struct.mesh import Mesh
-from mesh_model.mesh_struct.mesh_elements import Node
-from mesh_model.mesh_analysis.global_mesh_analysis import mesh_check
-from mesh_model.mesh_analysis.trimesh_analysis import isFlipOk, isCollapseOk, isSplitOk
+from mesh_model.mesh_analysis.trimesh_analysis import TriMeshTopoAnalysis, TriMeshGeoAnalysis
+from mesh_model.mesh_struct.mesh_elements import Node, Dart
+from view.mesh_plotter.mesh_plots import plot_mesh
 
+"""
+Actions triangulaires réalisées sur les maillages.
+Chaque fonction retourne trois booléens:
+* action_validity : Si l'action a été réalisée
+* topo : Si l'action est valide topologiquement
+* geo : si l'action est valide géométriquement
+"""
 
-def flip_edge_ids(mesh: Mesh, id1: int, id2: int) -> True:
-    return flip_edge(mesh, Node(mesh, id1), Node(mesh, id2))
+def flip_edge_ids(mesh_analysis, id1: int, id2: int) -> True:
+    return flip_edge(mesh_analysis, Node(mesh_analysis.mesh, id1), Node(mesh_analysis.mesh, id2))
 
 
-def flip_edge(mesh: Mesh, n1: Node, n2: Node) -> True:
-    found, d = mesh.find_inner_edge(n1, n2)
+def flip_edge(mesh_analysis, n1: Node, n2: Node) -> True:
+    found, d = mesh_analysis.mesh.find_inner_edge(n1, n2)
+
     if found:
-        topo, geo = isFlipOk(d)
+        topo, geo = mesh_analysis.isSplitOk(d)
         if not geo or not topo:
             return False, topo, geo
     else:
-        return False, False, False
+        return False, False, True  # the geometrical criteria is True because if the dart is not found, it means it's a boundary dart
+
 
-    d2, d1, d11, d21, d211, n1, n2, n3, n4 = mesh.active_triangles(d)
+    d2, d1, d11, d21, d211, n1, n2, n3, n4 = mesh_analysis.mesh.active_triangles(d)
 
     f1 = d.get_face()
     f2 = d2.get_face()
@@ -46,27 +54,29 @@ def flip_edge(mesh: Mesh, n1: Node, n2: Node) -> True:
     d2.set_node(n4)
     d211.set_face(f1)
     d11.set_face(f2)
+
+    check_mesh(mesh_analysis)
     return True, topo, geo
 
 
-def split_edge_ids(mesh: Mesh, id1: int, id2: int) -> True:
-    return split_edge(mesh, Node(mesh, id1), Node(mesh, id2))
+def split_edge_ids(mesh_analysis, id1: int, id2: int) -> True:
+    return split_edge(mesh_analysis, Node(mesh_analysis.mesh, id1), Node(mesh_analysis.mesh, id2))
 
 
-def split_edge(mesh: Mesh, n1: Node, n2: Node) -> True:
-    found, d = mesh.find_inner_edge(n1, n2)
+def split_edge(mesh_analysis, n1: Node, n2: Node) -> True:
+    found, d = mesh_analysis.mesh.find_inner_edge(n1, n2)
 
     if found:
-        topo, geo = isSplitOk(d)
+        topo, geo = mesh_analysis.isSplitOk(d)
         if not geo or not topo:
             return False, topo, geo
     else:
-        return False, True, False
+            return False, False, True # the geometrical criteria is True because if the dart is not found, it means it's a boundary dart
 
-    d2, d1, _, d21, _, n1, n2, n3, n4 = mesh.active_triangles(d)
+    d2, d1, _, d21, _, n1, n2, n3, n4 = mesh_analysis.mesh.active_triangles(d)
 
     # create a new node in the middle of [n1, n2]
-    N5 = mesh.add_node((n1.x() + n2.x()) / 2, (n1.y() + n2.y()) / 2)
+    N5 = mesh_analysis.mesh.add_node((n1.x() + n2.x()) / 2, (n1.y() + n2.y()) / 2)
 
     # modify existing triangles
     d1.set_node(N5)
@@ -75,64 +85,83 @@ def split_edge(mesh: Mesh, n1: Node, n2: Node) -> True:
     d2.set_beta(1, d21)
 
     # create 2 new triangles
-    F3 = mesh.add_triangle(n2, n3, N5)
-    F4 = mesh.add_triangle(N5, n1, n4)
+    F3 = mesh_analysis.mesh.add_triangle(n2, n3, N5)
+    F4 = mesh_analysis.mesh.add_triangle(N5, n1, n4)
 
     # update beta2 relations
-    mesh.set_face_beta2(F3, [d1, d2])
-    d2b2 = d2.get_beta(2)
-    d2b21 = d2b2.get_beta(1)
-    mesh.set_beta2(d2b21)
-    mesh.set_face_beta2(F4, [d, d21])
-    db2 = d.get_beta(2)
-    db21 = db2.get_beta(1)
-    mesh.set_beta2(db21)
+    mesh_analysis.mesh.set_face_beta2(F3, [d1, d2, d1.get_beta(2)])
+    mesh_analysis.mesh.set_face_beta2(F4, [d, d21, d21.get_beta(2)])
+
+    check_mesh(mesh_analysis)
     return True, topo, geo
 
 
-def collapse_edge_ids(mesh: Mesh, id1: int, id2: int) -> True:
-    return collapse_edge(mesh, Node(mesh, id1), Node(mesh, id2))
+def collapse_edge_ids(mesh_analysis, id1: int, id2: int) -> True:
+    return collapse_edge(mesh_analysis, Node(mesh_analysis.mesh, id1), Node(mesh_analysis.mesh, id2))
+
 
+def collapse_edge(mesh_analysis, n1: Node, n2: Node) -> True:
+    found, d = mesh_analysis.mesh.find_inner_edge(n1, n2)
 
-def collapse_edge(mesh: Mesh, n1: Node, n2: Node) -> True:
-    found, d = mesh.find_inner_edge(n1, n2)
     if found:
-        topo, geo = isCollapseOk(d)
+        topo, geo = mesh_analysis.isCollapseOk(d)
         if not geo or not topo:
             return False, topo, geo
     else:
-        return False, False, False
+        return False, False, True  # the geometrical criteria is True because if the dart is not found, it means it's a boundary dart
 
-    _, d1, d11, d21, d211, n1, n2, _, _ = mesh.active_triangles(d)
+    _, d1, d11, d21, d211, n1, n2, n3, n4 = mesh_analysis.mesh.active_triangles(d)
 
     d212 = d21.get_beta(2) #T1
     d2112 = d211.get_beta(2) #T2
     d12 = d1.get_beta(2) #T3
     d112 = d11.get_beta(2) #T4
 
     #Delete the darts around selected dart
-    mesh.del_adj_triangles(d)
+    mesh_analysis.mesh.del_adj_triangles(d)
 
     #Move n1 node in the middle of [n1, n2]
     n1.set_xy((n1.x() + n2.x()) / 2, (n1.y() + n2.y()) / 2)
+    i = 0
+
+    #Check if nodes n3 and n4 are not linked to deleted dart
+
+    if n3.get_dart().id == d11.id:
+        if d12 is not None:
+            n3.set_dart(d12)
+        else:
+            n3.set_dart(d112.get_beta(1))
+    if n4.get_dart().id == d211.id:
+        if d212 is not None:
+            n4.set_dart(d212)
+        else:
+            n4.set_dart(d2112.get_beta(1))
 
     #Update node relations
     if d12 is not None:
         d121 = d12.get_beta(1)
         d121.set_node(n1)
         ds = d121
         while ds is not None and ds != d2112:
+            i+=1
             d2s = ds.get_beta(2)
             if d2s is None:
                 ds = d2112
                 while ds is not None:
+                    i+=1
                     ds.set_node(n1)
                     ds1 = ds.get_beta(1)
                     ds11 = ds1.get_beta(1)
                     ds = ds11.get_beta(2)
+                    if i > 30:
+                        i = 0
+                        plot_mesh(mesh_analysis.mesh)
             else:
                 ds = d2s.get_beta(1)
                 ds.set_node(n1)
+            if i>30:
+                i=0
+                plot_mesh(mesh_analysis.mesh)
     """
     elif d12 is None and d2112 is not None:
         d2112.set_node(n1)
@@ -155,6 +184,24 @@ def collapse_edge(mesh: Mesh, n1: Node, n2: Node) -> True:
         d2112.set_beta(2, d212)
 
     #delete n2 node
-    mesh.del_node(n2)
+    mesh_analysis.mesh.del_node(n2)
+
+    check_mesh(mesh_analysis)
+    return True, topo, geo
 
-    return mesh_check(mesh), topo, geo
+def check_mesh(mesh_analysis):
+    for dart_info in mesh_analysis.mesh.active_darts():
+        #Check beta2 relation
+        d = dart_info[0]
+        d2 = dart_info[2]
+        if d2 >= 0 and mesh_analysis.mesh.dart_info[d2, 0] < 0:
+            raise ValueError("error beta2")
+        elif d2 >= 0 and mesh_analysis.mesh.dart_info[d2, 2] != d:
+            raise ValueError("error beta2")
+
+        #Check beta1
+        d = Dart(mesh_analysis.mesh, d)
+        d1 = d.get_beta(1)
+        d11 = d1.get_beta(1)
+        if d11.get_beta(1)!=d :
+            raise ValueError("error beta1")

environment/gymnasium_envs/quadmesh_env/envs/quadmesh.py

@@ -13,7 +13,7 @@
 
 from mesh_model.random_quadmesh import random_mesh
 from mesh_model.mesh_struct.mesh_elements import Dart
-from mesh_model.mesh_analysis.global_mesh_analysis import global_score
+from mesh_model.mesh_analysis.global_mesh_analysis import GlobalMeshAnalysis
 from mesh_model.mesh_analysis.quadmesh_analysis import isTruncated
 from environment.gymnasium_envs.quadmesh_env.envs.mesh_conv import get_x
 from environment.actions.quadrangular_actions import flip_edge_cntcw, flip_edge_cw, split_edge, collapse_edge, cleanup_edge
@@ -70,10 +70,10 @@ def __init__(
         else :
             self.config = {"mesh": None}
             self.mesh = random_mesh()
-
+        self.mesh_analysis = GlobalMeshAnalysis(self.mesh)
         #self.mesh_size = len(self.mesh.nodes)
         #self.nb_darts = len(self.mesh.dart_info)
-        self._nodes_scores, self._mesh_score, self._ideal_score, self._nodes_adjacency = global_score(self.mesh)
+        self._nodes_scores, self._mesh_score, self._ideal_score, self._nodes_adjacency = self.mesh_analysis.global_score()
         self._ideal_rewards = (self._mesh_score - self._ideal_score)*10 #arbitrary factor of 10 for rewards
         self.next_mesh_score = 0
         self.n_darts_selected = n_darts_selected
@@ -137,7 +137,7 @@ def reset(self, seed=None, options=None):
         else:
             self.mesh = random_mesh()
         #self.nb_darts = len(self.mesh.dart_info)
-        self._nodes_scores, self._mesh_score, self._ideal_score, self._nodes_adjacency = global_score(self.mesh)
+        self._nodes_scores, self._mesh_score, self._ideal_score, self._nodes_adjacency = self.mesh_analysis.global_score()
         self._ideal_rewards = (self._mesh_score - self._ideal_score) * 10
         self.nb_invalid_actions = 0
         self.close()
@@ -230,7 +230,7 @@ def step(self, action: np.ndarray):
 
         if valid_action:
             # An episode is done if the actual score is the same as the ideal
-            next_nodes_score, self.next_mesh_score, _, next_nodes_adjacency = global_score(self.mesh)
+            next_nodes_score, self.next_mesh_score, _, next_nodes_adjacency = self.mesh_analysis.global_score()
             terminated = np.array_equal(self._ideal_score, self.next_mesh_score)
             if terminated:
                 mesh_reward = (self._mesh_score - self.next_mesh_score)*10