New geometrical analysis for triangular meshes.

A geometrical quality criterion is now included in the observation.

This is so far only supported in a trimesh_full environment with action flip.

Author: ArzhelaR

environment/actions/triangular_actions.py

@@ -30,11 +30,11 @@ def flip_edge(mesh_analysis, n1: Node, n2: Node) -> 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)
+        topo, geo = mesh_analysis.isFlipOk(d)
         if not geo or not topo:
             return False, topo, geo
     else:
-        return False, False, True  # the geometrical criteria is True because if the dart is not found, it means it's a boundary dart
+        return False, False, True  # the geometrical criteria is True because if the dart is not found, it means it's a boundary dart and a topological criteria
 
 
     d2, d1, d11, d21, d211, n1, n2, n3, n4 = mesh_analysis.mesh.active_triangles(d)
@@ -65,10 +65,24 @@ def flip_edge(mesh_analysis, n1: Node, n2: Node) -> True:
     d211.set_face(f1)
     d11.set_face(f2)
 
-    topo = check_mesh(mesh_analysis, mesh_before)
-    if not topo:
-        mesh_analysis.mesh = deepcopy(mesh_before)
-        valid_action = False
+    #Update dart quality and nodes scores
+    d.set_quality(mesh_analysis.get_dart_geometric_quality(d))
+    d1.set_quality(mesh_analysis.get_dart_geometric_quality(d1))
+    d11.set_quality(mesh_analysis.get_dart_geometric_quality(d11))
+    d21.set_quality(mesh_analysis.get_dart_geometric_quality(d21))
+    d211.set_quality(mesh_analysis.get_dart_geometric_quality(d211))
+
+    n1.set_score(n1.get_score() + 1)
+    n2.set_score(n2.get_score() + 1)
+    n3.set_score(n3.get_score() - 1)
+    n4.set_score(n4.get_score() - 1)
+
+    after_check = check_mesh(mesh_analysis, mesh_before)
+    if not after_check:
+        raise ValueError("Some checks are missing")
+    # if not topo:
+    #     mesh_analysis.mesh = deepcopy(mesh_before)
+    #     valid_action = False
     return valid_action, topo, geo
 
 
@@ -222,6 +236,7 @@ def check_mesh(mesh_analysis, mesh_before=None) -> bool:
         # 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
@@ -236,13 +251,18 @@ def check_mesh(mesh_analysis, mesh_before=None) -> bool:
         #Check beta1
         if  mesh_analysis.mesh.dart_info[d11,1]!=d :
             return False
+        #check if the quality is the same for twin darts
+        if d2>=0 and mesh_analysis.mesh.dart_info[d2,5] != mesh_analysis.mesh.dart_info[d, 5]:
+            plot_mesh(mesh_analysis.mesh)
+            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:
+            if len(set([n1.id, n2.id, n3.id, n4.id])) < 4 and d.get_quality() != 3: # not flat faces
+                plot_mesh(mesh_analysis.mesh)
                 return False
-        return True
+    return True
 
 
 def check_mesh_debug(mesh_analysis, mesh_before=None)->True:

environment/gymnasium_envs/quadmesh_env/wrappers/__init__.py

@@ -2,4 +2,3 @@
 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/envs/mesh_conv.py

@@ -1,13 +1,12 @@
 import numpy as np
-from mesh_model.mesh_analysis.trimesh_analysis import TriMeshGeoAnalysis, TriMeshTopoAnalysis
-from mesh_model.mesh_struct.mesh_elements import Dart
+from mesh_model.mesh_struct.mesh_elements import Dart, Node
 from mesh_model.mesh_struct.mesh import Mesh
 
 
 def get_x(m_analysis, n_darts_selected: int, deep :int, degree: bool, restricted:bool, nodes_scores: list[int], nodes_adjacency: list[int]):
     mesh = m_analysis.mesh
     if degree:
-        template, darts_id = get_template_deg(m_analysis, deep, nodes_scores, nodes_adjacency)
+        template, darts_id = get_template_with_quality(m_analysis, deep)
     else:
         template, darts_id = get_template(m_analysis, deep, nodes_scores)
 
@@ -48,58 +47,71 @@ def get_template(m_analysis, deep: int, nodes_scores):
         C = d11.get_node()
 
         # Template niveau 1
-        template[n_darts - 1, 0] = nodes_scores[C.id]
-        template[n_darts - 1, 1] = nodes_scores[A.id]
-        template[n_darts - 1, 2] = nodes_scores[B.id]
+        template[n_darts - 1, 0] = C.get_score()
+        template[n_darts - 1, 1] = A.get_score()
+        template[n_darts - 1, 2] = B.get_score()
 
         if deep>3:
             # template niveau 2 deep = 6
             n_id = m_analysis.find_template_opposite_node(d)
             if n_id is not None:
-                template[n_darts - 1, 3] = nodes_scores[n_id]
+                template[n_darts - 1, 3] = n_id.get_score()
             n_id = m_analysis.find_template_opposite_node(d1)
             if n_id is not None:
-                template[n_darts - 1, 4] = nodes_scores[n_id]
+                template[n_darts - 1, 4] = n_id.get_score()
             n_id = m_analysis.find_template_opposite_node(d11)
             if n_id is not None:
-                template[n_darts - 1, 5] = nodes_scores[n_id]
+                template[n_darts - 1, 5] = n_id.get_score()
 
         if deep>6:
             # template niveau 3 - deep = 12
             d2, d1, d11, d21, d211, n1, n2, n3, n4 = m_analysis.mesh.active_triangles(d)
             #Triangle F2
             n_id = m_analysis.find_template_opposite_node(d21)
             if n_id is not None:
-                template[n_darts - 1, 6] = nodes_scores[n_id]
+                template[n_darts - 1, 6] = n_id.get_score()
             n_id = m_analysis.find_template_opposite_node(d211)
             if n_id is not None:
-                template[n_darts - 1, 7] = nodes_scores[n_id]
+                template[n_darts - 1, 7] = n_id.get_score()
             # Triangle T3
             d12 = d1.get_beta(2)
             d121 = d12.get_beta(1)
             d1211 = d121.get_beta(1)
             n_id = m_analysis.find_template_opposite_node(d121)
             if n_id is not None:
-                template[n_darts - 1, 8] = nodes_scores[n_id]
+                template[n_darts - 1, 8] = n_id.get_score()
             n_id = m_analysis.find_template_opposite_node(d1211)
             if n_id is not None:
-                template[n_darts - 1, 9] = nodes_scores[n_id]
+                template[n_darts - 1, 9] = n_id.get_score()
             # Triangle T4
             d112 = d11.get_beta(2)
             d1121 = d112.get_beta(1)
             d11211 = d1121.get_beta(1)
             n_id = m_analysis.find_template_opposite_node(d1121)
             if n_id is not None:
-                template[n_darts - 1, 10] = nodes_scores[n_id]
+                template[n_darts - 1, 10] = n_id.get_score()
             n_id = m_analysis.find_template_opposite_node(d11211)
             if n_id is not None:
-                template[n_darts - 1, 11] = nodes_scores[n_id]
+                template[n_darts - 1, 11] = n_id.get_score()
 
     template = template[:n_darts, :]
 
     return template, dart_ids
 
-def get_template_deg(m_analysis, deep: int, nodes_scores, nodes_adjacency):
+def get_template_with_quality(m_analysis, deep: int):
+    """
+    Create a template matrix representing the entire mesh, composed of:
+
+    * Node scores: i.e. the difference between ideal adjacency and actual adjacency.
+    * Dart surrounding quality: a measure of the geometric quality around each dart.
+
+    Each column in the matrix corresponds to the local surrounding of a dart,
+    including the scores of its surrounding nodes and its associated quality.
+
+    :param m_analysis: mesh to analyze
+    :param deep: observation deep (how many nodes observed on each dart surrounding)
+    :return: template matrix
+    """
     size = len(m_analysis.mesh.dart_info)
     template = np.zeros((size, deep*2), dtype=np.int64)
     dart_ids = []
@@ -117,27 +129,30 @@ def get_template_deg(m_analysis, deep: int, nodes_scores, nodes_adjacency):
         C = d11.get_node()
 
         # Template niveau 1
-        template[n_darts - 1, 0] = nodes_scores[C.id]
-        template[n_darts - 1, deep] = nodes_adjacency[C.id]
-        template[n_darts - 1, 1] = nodes_scores[A.id]
-        template[n_darts - 1, deep+1] = nodes_adjacency[A.id]
-        template[n_darts - 1, 2] = nodes_scores[B.id]
-        template[n_darts - 1, deep+2] = nodes_adjacency[B.id]
+        template[n_darts - 1, 0] = C.get_score()
+        template[n_darts - 1, deep] = d.get_quality()
+        template[n_darts - 1, 1] = A.get_score()
+        template[n_darts - 1, deep+1] = d1.get_quality()
+        template[n_darts - 1, 2] = B.get_score()
+        template[n_darts - 1, deep+2] = d11.get_quality()
 
         if deep>3:
             # template niveau 2
             n_id = m_analysis.find_template_opposite_node(d)
             if n_id is not None:
-                template[n_darts - 1, 3] = nodes_scores[n_id]
-                template[n_darts - 1, deep+3] = nodes_adjacency[n_id]
+                n = Node(m_analysis.mesh, n_id)
+                template[n_darts - 1, 3] = n.get_score()
+                template[n_darts - 1, deep+3] = d.get_quality() #quality around dart d is equivalent to quality around dart d2
             n_id = m_analysis.find_template_opposite_node(d1)
             if n_id is not None:
-                template[n_darts - 1, 4] = nodes_scores[n_id]
-                template[n_darts - 1, deep+4] = nodes_adjacency[n_id]
+                n = Node(m_analysis.mesh, n_id)
+                template[n_darts - 1, 3] = n.get_score()
+                template[n_darts - 1, deep+4] = d1.get_quality()
             n_id = m_analysis.find_template_opposite_node(d11)
             if n_id is not None:
-                template[n_darts - 1, 5] = nodes_scores[n_id]
-                template[n_darts - 1, deep+5] = nodes_adjacency[n_id]
+                n = Node(m_analysis.mesh, n_id)
+                template[n_darts - 1, 3] = n.get_score()
+                template[n_darts - 1, deep+5] = d11.get_quality()
 
         if deep>6:
             # template niveau 3 - deep = 12
@@ -146,38 +161,44 @@ def get_template_deg(m_analysis, deep: int, nodes_scores, nodes_adjacency):
                 #Triangle F2
                 n_id = m_analysis.find_template_opposite_node(d21)
                 if n_id is not None:
-                    template[n_darts - 1, 6] = nodes_scores[n_id]
-                    template[n_darts - 1, deep+6] = nodes_adjacency[n_id]
+                    n = Node(m_analysis.mesh, n_id)
+                    template[n_darts - 1, 3] = n.get_score()
+                    template[n_darts - 1, deep+6] = d21.get_quality()
                 n_id = m_analysis.find_template_opposite_node(d211)
                 if n_id is not None:
-                    template[n_darts - 1, 7] = nodes_scores[n_id]
-                    template[n_darts - 1, deep+7] = nodes_adjacency[n_id]
+                    n = Node(m_analysis.mesh, n_id)
+                    template[n_darts - 1, 3] = n.get_score()
+                    template[n_darts - 1, deep+7] = d211.get_quality()
             # Triangle T3
             d12 = d1.get_beta(2)
             if d12 is not None:
                 d121 = d12.get_beta(1)
                 d1211 = d121.get_beta(1)
                 n_id = m_analysis.find_template_opposite_node(d121)
                 if n_id is not None:
-                    template[n_darts - 1, 8] = nodes_scores[n_id]
-                    template[n_darts - 1, deep+8] = nodes_adjacency[n_id]
+                    n = Node(m_analysis.mesh, n_id)
+                    template[n_darts - 1, 3] = n.get_score()
+                    template[n_darts - 1, deep+8] = d121.get_quality()
                 n_id = m_analysis.find_template_opposite_node(d1211)
                 if n_id is not None:
-                    template[n_darts - 1, 9] = nodes_scores[n_id]
-                    template[n_darts - 1, deep+9] = nodes_adjacency[n_id]
+                    n = Node(m_analysis.mesh, n_id)
+                    template[n_darts - 1, 3] = n.get_score()
+                    template[n_darts - 1, deep+9] = d1211.get_quality()
             # Triangle T4
             d112 = d11.get_beta(2)
             if d112 is not None:
                 d1121 = d112.get_beta(1)
                 d11211 = d1121.get_beta(1)
                 n_id = m_analysis.find_template_opposite_node(d1121)
                 if n_id is not None:
-                    template[n_darts - 1, 10] = nodes_scores[n_id]
-                    template[n_darts - 1, deep+10] = nodes_adjacency[n_id]
+                    n = Node(m_analysis.mesh, n_id)
+                    template[n_darts - 1, 3] = n.get_score()
+                    template[n_darts - 1, deep+10] = d1121.get_quality()
                 n_id = m_analysis.find_template_opposite_node(d11211)
                 if n_id is not None:
-                    template[n_darts - 1, 11] = nodes_scores[n_id]
-                    template[n_darts - 1, deep+11] = nodes_adjacency[n_id]
+                    n = Node(m_analysis.mesh, n_id)
+                    template[n_darts - 1, 3] = n.get_score()
+                    template[n_darts - 1, deep+11] = d11211.get_quality()
 
     template = template[:n_darts, :]
     return template, dart_ids

environment/gymnasium_envs/trimesh_full_env/envs/trimesh.py

@@ -1,16 +1,19 @@
+from copy import deepcopy
 from enum import Enum
 import gymnasium as gym
 from gymnasium import spaces
 import pygame
 from pygame.locals import *
 import numpy as np
 import sys
+import imageio
 
 from mesh_model.random_trimesh import random_mesh
 from mesh_model.mesh_struct.mesh_elements import Dart
 from mesh_model.mesh_analysis.trimesh_analysis import TriMeshGeoAnalysis, TriMeshTopoAnalysis
 from environment.gymnasium_envs.trimesh_full_env.envs.mesh_conv import get_x
-from environment.actions.triangular_actions import flip_edge, split_edge, collapse_edge
+from environment.actions.triangular_actions import flip_edge, split_edge, collapse_edge, check_mesh
+from view.mesh_plotter.mesh_plots import plot_mesh
 from view.window import window_data, graph
 from mesh_display import MeshDisplay
 
@@ -27,7 +30,7 @@ class Actions(Enum):
 class TriMeshEnvFull(gym.Env):
     metadata = {"render_modes": ["human", "rgb_array"], "render_fps": 60}
 
-    def __init__(self, mesh=None, mesh_size=9, n_darts_selected=20, deep=6, with_degree_obs=False, action_restriction=False, render_mode=None):
+    def __init__(self, mesh=None, mesh_size=9, max_episode_steps=20, n_darts_selected=20, deep=6, with_degree_obs=False, action_restriction=False, render_mode=None):
         self.mesh = mesh if mesh is not None else random_mesh(mesh_size)
         self.m_analysis = TriMeshTopoAnalysis(self.mesh)
         self.mesh_size = mesh_size
@@ -44,6 +47,9 @@ def __init__(self, mesh=None, mesh_size=9, n_darts_selected=20, deep=6, with_deg
         self.nb_invalid_actions = 0
         self.darts_selected = [] # darts id observed
         deep = self.deep*2 if self.degree_observation else deep
+        self.episode_count = 0
+        self.ep_len = 0
+        self.max_steps = max_episode_steps
 
         self.observation_space = spaces.Box(
             low=-15,  # nodes min degree : 15
@@ -59,7 +65,6 @@ def __init__(self, mesh=None, mesh_size=9, n_darts_selected=20, deep=6, with_deg
 
         assert render_mode is None or render_mode in self.metadata["render_modes"]
         self.render_mode = render_mode
-
         """
         If human-rendering is used, `self.window` will be a reference
         to the window that we draw to. `self.clock` will be a clock that is used
@@ -92,10 +97,17 @@ def reset(self, seed=None, options=None):
         self._nodes_scores, self._mesh_score, self._ideal_score, self._nodes_adjacency = self.m_analysis.global_score()
         self._ideal_rewards = (self._mesh_score - self._ideal_score) * 10
         self.nb_invalid_actions = 0
+        self.ep_len = 0
         self.close()
         self.observation = self._get_obs()
         info = self._get_info(terminated=False,valid_act=(None,None,None), action=(None,None), mesh_reward=None)
 
+        """
+        if self._ideal_score !=0:
+            self.render_mode = "human"
+        else:
+            self.render_mode = None
+        """
         if self.render_mode == "human":
             self._render_frame()
             self.recording = True
@@ -113,6 +125,8 @@ def _get_obs(self):
 
     def _get_info(self, terminated, valid_act, action, mesh_reward):
         valid_action, valid_topo, valid_geo = valid_act
+        if self._mesh_score - self._ideal_score <0:
+            raise ValueError("score impossible")
         return {
             "distance": self._mesh_score - self._ideal_score,
             "mesh_reward" : mesh_reward,
@@ -139,13 +153,14 @@ def _action_to_dart_id(self, action: np.ndarray) -> int:
         return self.darts_selected[int(action[1])]
 
     def step(self, action: np.ndarray):
+        self.ep_len+=1
         dart_id = self._action_to_dart_id(action)
         d = Dart(self.mesh, dart_id)
         d1 = d.get_beta(1)
         n1 = d.get_node()
         n2 = d1.get_node()
         valid_action, valid_topo, valid_geo = False, False, False
-
+        before_mesh = deepcopy(self.mesh)
         if action[0] == Actions.FLIP.value:
             valid_action, valid_topo, valid_geo = flip_edge(self.m_analysis, n1, n2)
         elif action[0] == Actions.SPLIT.value:
@@ -160,6 +175,12 @@ def step(self, action: np.ndarray):
             next_nodes_score, self.next_mesh_score, _, next_nodes_adjacency = self.m_analysis.global_score()
             terminated = np.array_equal(self._ideal_score, self.next_mesh_score)
             mesh_reward = (self._mesh_score - self.next_mesh_score)*10
+            if mesh_reward == 10:
+                b_mesh_analysis = TriMeshTopoAnalysis(before_mesh)
+                plot_mesh(before_mesh)
+                plot_mesh(self.mesh)
+                bool1 = check_mesh(b_mesh_analysis)
+                bool2 = check_mesh(self.m_analysis)
             reward = mesh_reward
             self._nodes_scores, self._mesh_score, self._nodes_adjacency = next_nodes_score, self.next_mesh_score, next_nodes_adjacency
             self.observation = self._get_obs()
@@ -185,6 +206,12 @@ def step(self, action: np.ndarray):
 
         if self.render_mode == "human":
             self._render_frame()
+        #Saving episode rendering as gif
+        if terminated or self.ep_len>= self.max_steps:
+            if self.recording and self.frames:
+                imageio.mimsave(f"training/episode_recording/episode_{self.episode_count}.gif", self.frames, fps=1)
+                print("Image recorded")
+                self.episode_count +=1
 
         return self.observation, reward, terminated, truncated, info