The mesh analysis has been restructured.

A new feature has been added to mesh plotting: dart ID visualization.

Only the flip action is available.

New topological checks are performed after actions.

Author: ArzhelaR

environment/actions/smoothing.py

@@ -2,16 +2,19 @@
 
 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 GlobalMeshAnalysis
+from mesh_model.mesh_analysis.global_mesh_analysis import NodeAnalysis
+from view.mesh_plotter.mesh_plots import plot_mesh
+
 
 def smoothing_mean(mesh: Mesh) -> True:
     for i in range (20):
         #plot_mesh(mesh)
         for i, n_info in enumerate (mesh.nodes, start=0):
             if n_info[2] >=0:
                 node_to_smooth = Node(mesh, i)
-                if not on_boundary(node_to_smooth):
-                    list_darts = adjacent_darts(node_to_smooth)
+                na = NodeAnalysis(node_to_smooth)
+                if not na.on_boundary():
+                    list_darts = na.adjacent_darts()
                     sum_x = 0.0
                     sum_y = 0.0
                     nb_nodes = 0.0
@@ -21,4 +24,7 @@ def smoothing_mean(mesh: Mesh) -> True:
                             sum_x += n.x()
                             sum_y += n.y()
                             nb_nodes += 1
+                    if nb_nodes == 0:
+                        plot_mesh(mesh)
+                        raise ValueError("Isolated vertex ")
                     node_to_smooth.set_xy(sum_x/nb_nodes, sum_y/nb_nodes)

environment/actions/triangular_actions.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from copy import deepcopy
+
 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
@@ -17,8 +19,16 @@ def flip_edge_ids(mesh_analysis, id1: int, id2: int) -> True:
 
 
 def flip_edge(mesh_analysis, n1: Node, n2: Node) -> True:
+    """
+    Lors de la bascule d'arete, les relations beta2 ne sont pas impactées, seulement beta1.
+    :param mesh_analysis:
+    :param n1:
+    :param n2:
+    :return:
+    """
+    valid_action = True
     found, d = mesh_analysis.mesh.find_inner_edge(n1, n2)
-
+    mesh_before = deepcopy(mesh_analysis.mesh)
     if found:
         topo, geo = mesh_analysis.isSplitOk(d)
         if not geo or not topo:
@@ -55,8 +65,11 @@ def flip_edge(mesh_analysis, n1: Node, n2: Node) -> True:
     d211.set_face(f1)
     d11.set_face(f2)
 
-    check_mesh(mesh_analysis)
-    return True, topo, geo
+    topo = check_mesh(mesh_analysis, mesh_before)
+    if not topo:
+        mesh_analysis.mesh = deepcopy(mesh_before)
+        valid_action = False
+    return valid_action, topo, geo
 
 
 def split_edge_ids(mesh_analysis, id1: int, id2: int) -> True:
@@ -101,7 +114,8 @@ def collapse_edge_ids(mesh_analysis, id1: int, id2: int) -> True:
 
 
 def collapse_edge(mesh_analysis, n1: Node, n2: Node) -> True:
-    found, d = mesh_analysis.mesh.find_inner_edge(n1, n2)
+    mesh = mesh_analysis.mesh
+    found, d = mesh.find_inner_edge(n1, n2)
 
     if found:
         topo, geo = mesh_analysis.isCollapseOk(d)
@@ -110,11 +124,13 @@ def collapse_edge(mesh_analysis, n1: Node, n2: Node) -> True:
     else:
         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, n3, n4 = mesh_analysis.mesh.active_triangles(d)
+    d2, d1, d11, d21, d211, n1, n2, n3, n4 = mesh.active_triangles(d)
 
     d212 = d21.get_beta(2) #T1
     d2112 = d211.get_beta(2) #T2
     d12 = d1.get_beta(2) #T3
+    if not mesh.is_dart_active(d12):
+        print("error")
     d112 = d11.get_beta(2) #T4
 
     #Delete the darts around selected dart
@@ -127,27 +143,33 @@ def collapse_edge(mesh_analysis, n1: Node, n2: Node) -> True:
     #Check if nodes n3 and n4 are not linked to deleted dart
 
     if n3.get_dart().id == d11.id:
-        if d12 is not None:
+        if mesh.is_dart_active(d12):
             n3.set_dart(d12)
         else:
             n3.set_dart(d112.get_beta(1))
     if n4.get_dart().id == d211.id:
-        if d212 is not None:
+        if mesh.is_dart_active(d212):
             n4.set_dart(d212)
         else:
             n4.set_dart(d2112.get_beta(1))
+    if n1.get_dart().id == d.id or n1.get_dart().id == d21.id:
+        if mesh.is_dart_active(d112):
+            n1.set_dart(d112)
+        else:
+            n1.set_dart(d2112)
+
 
     #Update node relations
-    if d12 is not None:
+    if mesh.is_dart_active(d12):
         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:
+            if not mesh.is_dart_active(d2s):
                 ds = d2112
-                while ds is not None:
+                while mesh.is_dart_active(ds):
                     i+=1
                     ds.set_node(n1)
                     ds1 = ds.get_beta(1)
@@ -173,14 +195,14 @@ def collapse_edge(mesh_analysis, n1: Node, n2: Node) -> True:
             ds2 = ds.get_beta(2)
     """
     #update beta2 relations
-    if d112 is not None:
+    if mesh.is_dart_active(d112):
         d112.set_beta(2, d12)
-    if d12 is not None:
+    if mesh.is_dart_active(d12):
         d12.set_beta(2, d112)
 
-    if d212 is not None:
+    if mesh.is_dart_active(d212):
         d212.set_beta(2, d2112)
-    if d2112 is not None:
+    if mesh.is_dart_active(d2112):
         d2112.set_beta(2, d212)
 
     #delete n2 node
@@ -189,19 +211,87 @@ def collapse_edge(mesh_analysis, n1: Node, n2: Node) -> True:
     check_mesh(mesh_analysis)
     return True, topo, geo
 
-def check_mesh(mesh_analysis):
+def check_mesh(mesh_analysis, mesh_before=None) -> bool:
     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:
+            return False
+        # if beta2 relation is not symetrical
+        elif d2 >= 0 and mesh_analysis.mesh.dart_info[d2, 2] != d:
+            return False
+        # null dart
+        elif d2>=0 and mesh_analysis.mesh.dart_info[d2, 3] == mesh_analysis.mesh.dart_info[d, 3]:
+            return False
+        #if adjacent face is the same
+        elif  d2>=0 and mesh_analysis.mesh.dart_info[d2, 4] == mesh_analysis.mesh.dart_info[d, 4]:
+            return False
+
+
+        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 :
+            return False
+
+        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:
+                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
-        d = Dart(mesh_analysis.mesh, d)
-        d1 = d.get_beta(1)
-        d11 = d1.get_beta(1)
-        if d11.get_beta(1)!=d :
+        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")

environment/environment_config.json

@@ -1,9 +1,9 @@
 {
-    "env_name": "Quadmesh-v0",
-    "mesh_size": 16,
+    "env_name": "Trimesh-v0",
+    "mesh_size": 10,
     "max_episode_steps": 20,
-    "n_darts_selected": 10,
-    "deep": 8,
+    "n_darts_selected": 11,
+    "deep": 6,
     "action_restriction": false,
     "with_degree_observation": false
 }

environment/gymnasium_envs/quadmesh_env/wrappers/__init__.py

@@ -1,4 +1,5 @@
-from trimesh_env.wrappers.clip_reward import ClipReward
-from trimesh_env.wrappers.discrete_actions import DiscreteActions
-from trimesh_env.wrappers.reacher_weighted_reward import ReacherRewardWrapper
-from trimesh_env.wrappers.relative_position import RelativePosition
+from environment.gymnasium_envs.quadmesh_env.wrappers.clip_reward import ClipReward
+from environment.gymnasium_envs.quadmesh_env.wrappers.discrete_actions import DiscreteActions
+from environment.gymnasium_envs.quadmesh_env.wrappers.reacher_weighted_reward import ReacherRewardWrapper
+from environment.gymnasium_envs.quadmesh_env.wrappers.relative_position import RelativePosition
+from environment.gymnasium_envs.quadmesh_env.wrappers.dummy_vertices_observation import

environment/gymnasium_envs/trimesh_full_env/__init__.py

@@ -5,5 +5,5 @@
     id="Trimesh-v0",
     entry_point="environment.gymnasium_envs.trimesh_full_env.envs:TriMeshEnvFull",
     max_episode_steps=100,
-    kwargs={"mesh": None, "mesh_size": 30, "n_darts_selected": 20, "deep": 6, "with_degree_obs": True, "action_restriction": False},
+    kwargs={"mesh": None, "mesh_size": 7, "n_darts_selected": 20, "deep": 6, "with_degree_obs": False, "action_restriction": False},
 )