Merge pull request #60 from LIHPC-Computational-Geometry/59-quad-env

59 quad env

Author: ArzhelaR

actions/__init__.py renamed to environment/actions/__init__.py

@@ -0,0 +1,196 @@
+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 adjacent_darts, degree, mesh_check
+from mesh_model.mesh_analysis.quadmesh_analysis import isFlipOk, isCollapseOk, isSplitOk, isCleanupOk
+
+
+def flip_edge_ids(mesh: Mesh, id1: int, id2: int) -> True:
+    return flip_edge(mesh, Node(mesh, id1), Node(mesh, id2))
+
+
+def flip_edge(mesh: Mesh, n1: Node, n2: Node) -> (True, True, True):
+    found, d = mesh.find_inner_edge(n1, n2)
+
+    if found:
+        topo, geo = isFlipOk(d)
+        if not geo or not topo:
+            return False, topo, geo
+    else:
+        return False, False, False
+
+    d2, d1, d11, d111, d21, d211, d2111, n1, n2, n3, n4, n5, n6 = mesh.active_quadrangles(d)
+
+    f1 = d.get_face()
+    f2 = d2.get_face()
+
+    # Update beta 1
+    d.set_beta(1, d11)
+    d111.set_beta(1, d21)
+    d21.set_beta(1, d)
+    d2.set_beta(1, d211)
+    d2111.set_beta(1, d1)
+    d1.set_beta(1, d2)
+
+
+    if n1.get_dart().id == d.id:
+        n1.set_dart(d21)
+    if n2.get_dart().id == d2.id:
+        n2.set_dart(d1)
+
+    if f1.get_dart().id == d1.id:
+        f1.set_dart(d)
+
+    if f2.get_dart().id == d21.id:
+        f2.set_dart(d2)
+
+    d.set_node(n5)
+    d2.set_node(n3)
+    d21.set_face(f1)
+    d1.set_face(f2)
+
+    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(mesh: Mesh, n1: Node, n2: Node) -> True:
+    found, d = mesh.find_inner_edge(n1, n2)
+
+    if found:
+        topo, geo = isSplitOk(d)
+        if not geo or not topo:
+            return False, topo, geo
+    else:
+        return False, True, False
+
+    d2, d1, d11, d111, d21, d211, d2111, n1, n2, n3, n4, n5, n6 = mesh.active_quadrangles(d)
+    d1112 = d111.get_beta(2)
+    d212 = d21.get_beta(2)
+
+    # create a new node in the middle of [n1, n2]
+    N10 = mesh.add_node((n1.x() + n2.x()) / 2, (n1.y() + n2.y()) / 2)
+
+    # modify existing triangles
+    d.set_node(N10)
+    d21.set_node(N10)
+
+    # create a new quadrangle
+    f5 = mesh.add_quad(n1, n5, N10, n4)
+
+    # update beta2 relations
+    mesh.set_face_beta2(f5,[d111,d1112,d21,d212])
+
+    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(mesh: Mesh, n1: Node, n2: Node) -> True:
+    found, d = mesh.find_inner_edge(n1, n2)
+    if found:
+        topo, geo = isCollapseOk(d)
+        if not geo or not topo:
+            return False, topo, geo
+    else:
+        return False, False, False
+
+    d2, d1, d11, d111, d21, d211, d2111, n1, n2, n3, n4, n5, n6 = mesh.active_quadrangles(d)
+
+    d1112 = d111.get_beta(2)
+    d12 = d1.get_beta(2)
+    d112 = d11.get_beta(2)
+
+    # Move n3 node in the middle of [n3, n1]
+    n3.set_xy((n3.x() + n1.x()) / 2, (n1.y() + n3.y()) / 2)
+
+    #Delete the face F5
+    f5 = d.get_face()
+    mesh.del_quad(d, d1, d11, d111, f5)
+
+    n_from = n1
+    n_to = n3
+    adj_darts = adjacent_darts(n_from)
+
+    for d in adj_darts:
+        if d.get_node() == n_from:
+            d.set_node(n_to)
+    mesh.del_node(n_from)
+
+    #Update beta2 relations
+    if d2 is not None:
+        d2.set_beta(2, d12)
+        d21 = d2.get_beta(1)
+        d21.set_node(n3)
+    if d1112 is not None:
+        d1112.set_beta(2, d112)
+        d1112.set_node(n3)
+    if d12 is not None:
+        d12.set_beta(2, d2)
+    if d112 is not None:
+        d112.set_beta(2, d1112)
+
+    return mesh_check(mesh), topo, geo
+
+
+def cleanup_edge_ids(mesh: Mesh, id1: int, id2: int) -> True:
+    return cleanup_edge(mesh, Node(mesh, id1), Node(mesh, id2))
+
+def cleanup_edge(mesh: Mesh, n1: Node, n2: Node) -> True:
+    found, d = mesh.find_inner_edge(n1, n2)
+    if found:
+        topo, geo = isCleanupOk(d)
+        if not geo or not topo:
+            return False, topo, geo
+    else:
+        return False, False, False
+
+    parallel_darts = mesh.find_parallel_darts(d)
+
+    last_dart = parallel_darts[-1]
+    ld1 = last_dart.get_beta(1)
+    ld11 = ld1.get_beta(1)
+    ld111 = ld11.get_beta(1)
+    last_node = ld111.get_node()
+    node_to = ld11.get_node()
+    adj_darts = adjacent_darts(last_node)
+    mesh.del_node(last_node)
+
+    for da in adj_darts:
+        if da.get_node() == last_node:
+            da.set_node(node_to)
+
+    for d in parallel_darts:
+        f = d.get_face()
+        d1 = d.get_beta(1)
+        d11 = d1.get_beta(1)
+        d111 = d11.get_beta(1)
+
+        n_from = d.get_node()
+        n_to = d1.get_node()
+
+        # update beta 2 relations
+        d12 = d1.get_beta(2)
+        d1112 = d111.get_beta(2)
+        if d1112 is not None:
+            d1112.set_beta(2, d12)
+        if d12 is not None:
+            d12.set_beta(2, d1112)
+
+        mesh.del_quad(d, d1, d11, d111, f)
+
+        adj_darts = adjacent_darts(n_from)
+
+        for d in adj_darts:
+            if d.get_node() == n_from:
+                d.set_node(n_to)
+        mesh.del_node(n_from)
+
+    return mesh_check(mesh), topo, geo
+
+

environment/actions/quadrangular_actions.py

@@ -0,0 +1,24 @@
+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 adjacent_darts, on_boundary
+
+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)
+                    sum_x = 0.0
+                    sum_y = 0.0
+                    nb_nodes = 0.0
+                    for d in list_darts:
+                        n = d.get_node()
+                        if n != node_to_smooth:
+                            sum_x += n.x()
+                            sum_y += n.y()
+                            nb_nodes += 1
+                    node_to_smooth.set_xy(sum_x/nb_nodes, sum_y/nb_nodes)

environment/actions/smoothing.py

@@ -1,8 +1,9 @@
 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_analysis import isFlipOk, isCollapseOk, isSplitOk
+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
 
 
 def flip_edge_ids(mesh: Mesh, id1: int, id2: int) -> True:
@@ -78,11 +79,11 @@ def split_edge(mesh: Mesh, n1: Node, n2: Node) -> True:
     F4 = mesh.add_triangle(N5, n1, n4)
 
     # update beta2 relations
-    mesh.set_face_beta2(F3, (d1, d2))
+    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))
+    mesh.set_face_beta2(F4, [d, d21])
     db2 = d.get_beta(2)
     db21 = db2.get_beta(1)
     mesh.set_beta2(db21)
@@ -157,45 +158,3 @@ def collapse_edge(mesh: Mesh, n1: Node, n2: Node) -> True:
     mesh.del_node(n2)
 
     return mesh_check(mesh), topo, geo
-
-
-def check_beta2_relation(mesh: Mesh) -> bool:
-    for dart_info in mesh.active_darts():
-        d = dart_info[0]
-        d2 = dart_info[2]
-        if d2 >= 0 and mesh.dart_info[d2, 0] < 0:
-            raise ValueError("error beta2")
-        elif d2 >= 0 and mesh.dart_info[d2, 2] != d:
-            raise ValueError("error beta2")
-    return True
-
-
-def check_double(mesh: Mesh) -> bool:
-    for dart_info in mesh.active_darts():
-        d = Dart(mesh, dart_info[0])
-        d2 = Dart(mesh, dart_info[2]) if dart_info[2] >= 0 else None
-        n1 = dart_info[3]
-        if d2 is None:
-            d1 = d.get_beta(1)
-            n2 = d1.get_node().id
-        else:
-            n2 = d2.get_node().id
-        for dart_info2 in mesh.active_darts():
-            ds = Dart(mesh, dart_info2[0])
-            ds2 = Dart(mesh, dart_info2[2]) if dart_info2[2] >= 0 else None
-            if d != ds and d != ds2:
-                ns1 = dart_info2[3]
-                if ds2 is None:
-                    ds1 = ds.get_beta(1)
-                    ns2 = ds1.get_node().id
-                else:
-                    ns2 = ds2.get_node().id
-
-                if n1 == ns1 and n2 == ns2:
-                    raise ValueError("double error")
-                elif n2 == ns1 and n1 == ns2:
-                    return False
-    return True
-
-def mesh_check(mesh: Mesh) -> bool:
-    return check_double(mesh) and check_beta2_relation(mesh)

actions/triangular_actions.py renamed to environment/actions/triangular_actions.py

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

environment/parameters/environment_config.json renamed to environment/environment_config.json

@@ -0,0 +1,9 @@
+from gymnasium.envs.registration import register
+from environment.gymnasium_envs.quadmesh_env.envs.quadmesh import QuadMeshEnv
+
+register(
+    id="Quadmesh-v0",
+    entry_point="environment.gymnasium_envs.quadmesh_env.envs:QuadMeshEnv",
+    max_episode_steps=100,
+    kwargs={"mesh": None, "n_darts_selected": 20, "deep": 6, "with_degree_obs": True, "action_restriction": False},
+)

environment/gymnasium_envs/quadmesh_env/__init__.py

@@ -0,0 +1 @@
+from environment.gymnasium_envs.quadmesh_env.envs.quadmesh import QuadMeshEnv