New test functions for quad environment.

ArzhelaR · ArzhelaR · commit c29a86065a60 · 2025-03-31T08:09:42.000+02:00
diff --git a/environment/actions/quadrangular_actions.py b/environment/actions/quadrangular_actions.py
@@ -84,12 +84,6 @@ def split_edge(mesh: Mesh, n1: Node, n2: Node) -> True:
     # update beta2 relations
     mesh.set_face_beta2(f5,[d111,d1112,d21,d212])
 
-    adj_n1 = adjacent_darts(n1)
-    adj_n2 = adjacent_darts(N10)
-
-    deg1 = degree(n1)
-    deg2 = degree(N10)
-
     return True, topo, geo
 
 
diff --git a/environment/actions/triangular_actions.py b/environment/actions/triangular_actions.py
@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from mesh_model.mesh_struct.mesh import Mesh
-from mesh_model.mesh_struct.mesh_elements import Dart, Node
+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
 
diff --git a/environment/gymnasium_envs/quadmesh_env/envs/quadmesh.py b/environment/gymnasium_envs/quadmesh_env/envs/quadmesh.py
@@ -6,7 +6,8 @@
 
 from mesh_model.random_quadmesh import random_mesh
 from mesh_model.mesh_struct.mesh_elements import Dart
-from mesh_model.mesh_analysis.quadmesh_analysis import global_score, isTruncated
+from mesh_model.mesh_analysis.global_mesh_analysis import global_score
+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, split_edge, collapse_edge, cleanup_edge
 from environment.observation_register import ObservationRegistry
diff --git a/environment/gymnasium_envs/trimesh_flip_env/envs/trimesh.py b/environment/gymnasium_envs/trimesh_flip_env/envs/trimesh.py
@@ -5,7 +5,8 @@
 
 from mesh_model.random_trimesh import random_flip_mesh
 from mesh_model.mesh_struct.mesh_elements import Dart
-from mesh_model.mesh_analysis.trimesh_analysis import global_score, isTruncated
+from mesh_model.mesh_analysis.global_mesh_analysis import global_score
+from mesh_model.mesh_analysis.trimesh_analysis import isTruncated
 from environment.gymnasium_envs.trimesh_flip_env.envs.mesh_conv import get_x
 from environment.actions.triangular_actions import flip_edge
 
diff --git a/environment/gymnasium_envs/trimesh_full_env/envs/trimesh.py b/environment/gymnasium_envs/trimesh_full_env/envs/trimesh.py
@@ -6,7 +6,8 @@
 
 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 global_score, isTruncated
+from mesh_model.mesh_analysis.global_mesh_analysis import global_score
+from mesh_model.mesh_analysis.trimesh_analysis import isTruncated
 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
 
diff --git a/environment/trimesh_env.py b/environment/trimesh_env.py
@@ -1,6 +1,7 @@
 import math
 import numpy as np
-from mesh_model.mesh_analysis.trimesh_analysis import global_score, find_template_opposite_node
+from mesh_model.mesh_analysis.trimesh_analysis import find_template_opposite_node
+from mesh_model.mesh_analysis.global_mesh_analysis import global_score
 from mesh_model.mesh_struct.mesh_elements import Dart
 from mesh_model.mesh_struct.mesh import Mesh
 from environment.actions.triangular_actions import flip_edge, split_edge, collapse_edge
diff --git a/mesh_display.py b/mesh_display.py
@@ -1,5 +1,5 @@
 from mesh_model.mesh_struct.mesh import Mesh
-from mesh_model.mesh_analysis.trimesh_analysis import global_score
+from mesh_model.mesh_analysis.global_mesh_analysis import global_score
 
 
 class MeshDisplay:
diff --git a/mesh_model/mesh_analysis/quadmesh_analysis.py b/mesh_model/mesh_analysis/quadmesh_analysis.py
@@ -1,52 +1,8 @@
-from math import sqrt, degrees, radians, cos, sin, acos
 import numpy as np
 
 from mesh_model.mesh_struct.mesh_elements import Dart, Node, Face
 from mesh_model.mesh_struct.mesh import Mesh
-from mesh_model.mesh_analysis.global_mesh_analysis import test_degree, on_boundary, get_angle_by_coord, degree, \
-    get_boundary_angle, adjacent_darts, adjacent_faces
-
-
-def global_score(m: Mesh):
-    """
-    Calculate the overall mesh score. The mesh cannot achieve a better score than the ideal one.
-    And the current score is the mesh score.
-    :param m: the mesh to be analyzed
-    :return: 4 return: a list of the nodes score, the current mesh score and the ideal mesh score, and the adjacency
-    """
-    mesh_ideal_score = 0
-    mesh_score = 0
-    nodes_score = []
-    nodes_adjacency = []
-    for i in range(len(m.nodes)):
-        if m.nodes[i, 2] >= 0:
-            n_id = i
-            node = Node(m, n_id)
-            n_score, adjacency= score_calculation(node)
-            nodes_score.append(n_score)
-            nodes_adjacency.append(adjacency)
-            mesh_ideal_score += n_score
-            mesh_score += abs(n_score)
-        else:
-            nodes_score.append(0)
-            nodes_adjacency.append(6)
-    return nodes_score, mesh_score, mesh_ideal_score, nodes_adjacency
-
-
-def score_calculation(n: Node) -> (int, int):
-    """
-    Function to calculate the irregularity of a node in the mesh.
-    :param n: a node in the mesh.
-    :return: the irregularity of the node
-    """
-    adjacency = degree(n)
-    if on_boundary(n):
-        angle = get_boundary_angle(n)
-        ideal_adjacency = max(round(angle/90)+1, 2)
-    else:
-        ideal_adjacency = 360/90
-
-    return ideal_adjacency-adjacency, adjacency
+from mesh_model.mesh_analysis.global_mesh_analysis import test_degree, on_boundary, adjacent_faces
 
 
 def isValidAction(mesh: Mesh, dart_id: int, action: int) -> (bool, bool):
@@ -271,50 +227,7 @@ def isValidQuad(A: Node, B: Node, C: Node, D: Node):
         return False
 
     """
-    if 0< signe(cp_A)+signe(cp_B)+signe(cp_C)+signe(cp_D) <2 :
+    if 0<= signe(cp_A)+signe(cp_B)+signe(cp_C)+signe(cp_D) <2 :
         return True
     else:
         return False
-
-
-def orientation(p, q, r):
-    """ Calcule l'orientation de trois points.
-        Retourne :
-        0 si colinéaire,
-        1 si sens anti-horaire,
-        2 si sens horaire.
-    """
-    val = (q[1] - p[1]) * (r[0] - q[0]) - (q[0] - p[0]) * (r[1] - q[1])
-    if val == 0:
-        return 0
-    return 1 if val > 0 else 2
-
-def do_intersect(p1, q1, p2, q2):
-    """ Vérifie si les segments [p1,q1] et [p2,q2] s'intersectent """
-    o1 = orientation(p1, q1, p2)
-    o2 = orientation(p1, q1, q2)
-    o3 = orientation(p2, q2, p1)
-    o4 = orientation(p2, q2, q1)
-
-    # Cas général : les orientations sont différentes
-    if o1 != o2 and o3 != o4:
-        return True
-
-    return False  # Pas d'intersection
-
-def is_self_intersecting_quadrilateral(A, B, C, D):
-    """ Vérifie si le quadrilatère ABCD est croisé """
-    return do_intersect(A, C, B, D)  # Vérifie l'intersection des diagonales
-
-
-"""
-d12 = d1.get_beta(2)
-d112 = d11.get_beta(2)
-d1112 = d111.get_beta(2)
-n7 = ((d1112.get_beta(1)).get_beta(1)).get_node()
-n8 = ((d112.get_beta(1)).get_beta(1)).get_node()
-n9 = (((d112.get_beta(1)).get_beta(1)).get_beta(1)).get_node()
-n11 = ((d12.get_beta(1)).get_beta(1)).get_node()
-n10 = mesh.add_node((n1.x() + n3.x()) / 2, (n1.y() + n3.y()) / 2)
-topo = isValidQuad(n10, n5, n6, n2) and isValidQuad(n4, n10, n2, n3) and isValidQuad(n10, n5, n6, n2)
-"""
diff --git a/mesh_model/mesh_analysis/trimesh_analysis.py b/mesh_model/mesh_analysis/trimesh_analysis.py
@@ -1,53 +1,10 @@
-from math import sqrt, degrees, radians, cos, sin, acos
-import numpy as np
+from math import sqrt, degrees, radians, cos, sin
 
 from mesh_model.mesh_struct.mesh_elements import Dart, Node, Face
 from mesh_model.mesh_struct.mesh import Mesh
 from mesh_model.mesh_analysis.global_mesh_analysis import get_boundary_darts, test_degree, on_boundary, get_angle_by_coord, angle_from_sides, degree, get_boundary_angle
 
 
-def global_score(m: Mesh):
-    """
-    Calculate the overall mesh score. The mesh cannot achieve a better score than the ideal one.
-    And the current score is the mesh score.
-    :param m: the mesh to be analyzed
-    :return: 4 return: a list of the nodes score, the current mesh score and the ideal mesh score, and the adjacency
-    """
-    mesh_ideal_score = 0
-    mesh_score = 0
-    nodes_score = []
-    nodes_adjacency = []
-    for i in range(len(m.nodes)):
-        if m.nodes[i, 2] >= 0:
-            n_id = i
-            node = Node(m, n_id)
-            n_score, adjacency= score_calculation(node)
-            nodes_score.append(n_score)
-            nodes_adjacency.append(adjacency)
-            mesh_ideal_score += n_score
-            mesh_score += abs(n_score)
-        else:
-            nodes_score.append(0)
-            nodes_adjacency.append(6)
-    return nodes_score, mesh_score, mesh_ideal_score, nodes_adjacency
-
-
-def score_calculation(n: Node) -> (int, int):
-    """
-    Function to calculate the irregularity of a node in the mesh.
-    :param n: a node in the mesh.
-    :return: the irregularity of the node
-    """
-    adjacency = degree(n)
-    if on_boundary(n):
-        angle = get_boundary_angle(n)
-        ideal_adjacency = max(round(angle/60)+1, 2)
-    else:
-        ideal_adjacency = 360/60
-
-    return ideal_adjacency-adjacency, adjacency
-
-
 def isValidAction(mesh: Mesh, dart_id: int, action: int) -> (bool, bool):
     flip = 0
     split = 1
diff --git a/test_modules/test_actions_quad.py b/test_modules/test_actions_quad.py
@@ -33,10 +33,11 @@ def test_flip(self):
         self.assertEqual(d2.get_node(), n10)
 
 
-        flip_edge(cmap, n11, n10)
+        self.assertEqual(flip_edge(cmap, n11, n10), (True,True,True))
         self.assertEqual(2, cmap.nb_faces())
         self.assertEqual(6, cmap.nb_nodes())
         plot_mesh(cmap)
+        self.assertFalse(flip_edge(cmap, n11, n10)[0])
 
     def test_split(self):
         cmap = mesh.Mesh()
@@ -56,8 +57,13 @@ def test_split(self):
         q4 = cmap.add_quad(n01, n11, n12, n02)
         cmap.set_twin_pointers()
         plot_mesh(cmap)
-        split_edge(cmap, n11, n21)
+        found, d = cmap.find_inner_edge(n11, n21)
+        self.assertTrue(found)
+        self.assertEqual(split_edge(cmap, n11, n21), (True,True,True))
+        self.assertEqual(10, cmap.nb_nodes())
+        self.assertEqual(5, cmap.nb_faces())
         plot_mesh(cmap)
+        self.assertFalse(split_edge(cmap, n20, n21)[0])
 
     def test_collapse(self):
         cmap = mesh.Mesh()
@@ -79,8 +85,14 @@ def test_collapse(self):
         q5 = cmap.add_quad(n051, n10, n151, n12)
         cmap.set_twin_pointers()
         plot_mesh(cmap)
-        collapse_edge(cmap, n151, n12)
+        found, d = cmap.find_inner_edge(n151, n12)
+        self.assertTrue(found)
         plot_mesh(cmap)
+        self.assertEqual(collapse_edge(cmap, n151, n12), (True, True, True))
+        self.assertEqual(9, cmap.nb_nodes())
+        self.assertEqual(4, cmap.nb_faces())
+        plot_mesh(cmap)
+        self.assertFalse(split_edge(cmap, n20, n21)[0])
 
     def test_cleanup(self):
         cmap = mesh.Mesh()
@@ -102,7 +114,11 @@ def test_cleanup(self):
         q5 = cmap.add_quad(n051, n10, n151, n12)
         cmap.set_twin_pointers()
         plot_mesh(cmap)
-        cleanup_edge(cmap, n151, n21)
+        found, d = cmap.find_inner_edge(n151, n12)
+        self.assertTrue(found)
+        self.assertEqual(cleanup_edge(cmap, n151, n21), (True, True, True))
+        self.assertEqual(7, cmap.nb_nodes())
+        self.assertEqual(3, cmap.nb_faces())
         plot_mesh(cmap)
 
 
@@ -113,12 +129,12 @@ def test_actions(self):
         d = Dart(cmap, 14)
         n1= d.get_node()
         n2 = (d.get_beta(1)).get_node()
-        collapse_edge(cmap, n1, n2)
+        self.assertEqual(collapse_edge(cmap, n1, n2), (True,True,True))
         plot_mesh(cmap)
         d = Dart(cmap, 32)
         n1 = d.get_node()
         n2 = (d.get_beta(1)).get_node()
-        flip_edge(cmap, n1, n2)
+        self.assertEqual(flip_edge(cmap, n1, n2), (True,True,True))
 
         plot_mesh(cmap)
 
diff --git a/test_modules/test_quadrangular_mesh_analysis.py b/test_modules/test_quadrangular_mesh_analysis.py
@@ -0,0 +1,96 @@
+import unittest
+import os
+
+from mesh_model.mesh_struct.mesh import Mesh
+from mesh_model.mesh_struct.mesh_elements import Dart
+import mesh_model.mesh_analysis.global_mesh_analysis as GMA
+import mesh_model.mesh_analysis.quadmesh_analysis as QMA
+from environment.actions.triangular_actions import split_edge_ids
+from view.mesh_plotter.mesh_plots import plot_mesh
+from mesh_model.reader import read_gmsh
+
+TESTFILE_FOLDER = os.path.join(os.path.dirname(__file__), '../mesh_files/')
+
+class TestMeshAnalysis(unittest.TestCase):
+
+    def test_mesh_regular_score(self):
+        nodes = [[0.0, 0.0], [1.0, 0.0], [2.0, 0.0], [0.0, 1.0], [1.0, 1.0], [2.0, 1.0], [0.0, 2.0], [1.0, 2.0], [2.0, 2.0], [3.0, 3.0]]
+        faces = [[0, 1, 4, 3], [1, 2, 5, 4], [3, 4, 7, 6], [4, 5, 8, 7]]
+        cmap = Mesh(nodes,faces)
+        nodes_score, mesh_score, mesh_ideal_score, adjacency = GMA.global_score(cmap)
+        self.assertEqual((0,0), (mesh_score, mesh_ideal_score) )
+
+    def test_mesh_with_irregularities(self):
+        filename = os.path.join(TESTFILE_FOLDER, 't1_quad.msh')
+        cmap = read_gmsh(filename)
+        nodes_score, mesh_score, mesh_ideal_score, adjacency = GMA.global_score(cmap)
+        self.assertIsNot((0, 0), (mesh_score,mesh_ideal_score) )
+
+    def test_is_valid_action(self):
+        filename = os.path.join(TESTFILE_FOLDER, 't1_quad.msh')
+        cmap = read_gmsh(filename)
+
+        #Boundary dart
+        self.assertEqual(QMA.isValidAction(cmap, 20, 0), (False, True))
+
+        # Flip test
+        self.assertEqual(QMA.isValidAction(cmap, 3, 0), (True, True))
+        self.assertEqual(QMA.isValidAction(cmap, 27, 0), (False, True))
+
+        #Split test
+        self.assertEqual(QMA.isValidAction(cmap, 0, 1), (True, True))
+        self.assertEqual(QMA.isValidAction(cmap, 27, 1), (False, True))
+
+        #Collapse test
+        self.assertEqual(QMA.isValidAction(cmap, 0, 2), (True, True))
+        plot_mesh(cmap)
+        self.assertEqual(QMA.isValidAction(cmap, 27, 2), (False, True))
+
+        #All action test
+        self.assertEqual(QMA.isValidAction(cmap, 27, 3), (False, True))
+        self.assertEqual(QMA.isValidAction(cmap, 9, 3), (True, True))
+
+        #One action test
+        self.assertEqual(QMA.isValidAction(cmap, 0, 4), (True, True))
+        self.assertEqual(QMA.isValidAction(cmap, 9, 4), (True, True))
+        self.assertEqual(QMA.isValidAction(cmap, 27, 4), (False, True))
+
+        #Invalid action
+        with self.assertRaises(ValueError):
+            QMA.isValidAction(cmap, 0, 6)
+
+    def test_valid_triangle(self):
+        # test Lmax invalid
+        vect_AB = (5.0, 0.0)
+        vect_AC = (2.5, 5.0)
+        vect_BC = (-2.5, 5.0)
+        self.assertFalse(QMA.valid_triangle(vect_AB, vect_AC, vect_BC))
+        # test invalid angles
+        vect_AB = (3.0, 0.0)
+        vect_AC = (1.5, 0.05)
+        vect_BC = (-1.5, 0.05)
+        self.assertFalse(QMA.valid_triangle(vect_AB, vect_AC, vect_BC))
+        # test valid triangle
+        vect_AB = (3.0, 0.0)
+        vect_AC = (1.5, 3.0)
+        vect_BC = (-1.5, 3.0)
+        self.assertTrue(QMA.valid_triangle(vect_AB, vect_AC, vect_BC))
+
+    def test_isTruncated(self):
+        nodes = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0]]
+        faces = [[0, 1, 2]]
+        cmap = Mesh(nodes, faces)
+        darts_list = []
+        for d_info in cmap.active_darts():
+            darts_list.append(d_info[0])
+        self.assertTrue(QMA.isTruncated(cmap, darts_list))
+        nodes = [[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0], [2.0, 0.0]]
+        faces = [[0, 1, 2], [0, 2, 3], [1, 4, 2]]
+        cmap = Mesh(nodes, faces)
+        darts_list = []
+        for d_info in cmap.active_darts():
+            darts_list.append(d_info[0])
+        self.assertFalse(QMA.isTruncated(cmap, darts_list))
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/test_modules/test_random_quadmesh.py b/test_modules/test_random_quadmesh.py
diff --git a/test_modules/test_random_trimesh.py b/test_modules/test_random_trimesh.py
diff --git a/test_modules/test_triangular_mesh_analysis.py b/test_modules/test_triangular_mesh_analysis.py
diff --git a/training/exploit_SB3_policy.py b/training/exploit_SB3_policy.py
