File reorganisation, for clean implementation of PPO on quad files.

Author: ArzhelaR

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

@@ -1,8 +1,8 @@
 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.mesh_analysis import adjacent_darts, degree, mesh_check
+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
 
 
@@ -198,3 +198,5 @@ def cleanup_edge(mesh: Mesh, n1: Node, n2: Node) -> True:
         mesh.del_node(n_from)
 
     return mesh_check(mesh), topo, geo
+
+

actions/quadrangular_actions.py …ironment/actions/quadrangular_actions.pyactions/quadrangular_actions.py renamed to environment/actions/quadrangular_actions.py actions/quadrangular_actions.py renamed to 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

@@ -2,7 +2,7 @@
 
 from mesh_model.mesh_struct.mesh import Mesh
 from mesh_model.mesh_struct.mesh_elements import Dart, Node
-from mesh_model.mesh_analysis.mesh_analysis import mesh_check
+from mesh_model.mesh_analysis.global_mesh_analysis import mesh_check
 from mesh_model.mesh_analysis.trimesh_analysis import isFlipOk, isCollapseOk, isSplitOk
 
 

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

@@ -2,8 +2,8 @@
     "env_name": "Quadmesh-v0",
     "mesh_size": 16,
     "max_episode_steps": 30,
-    "n_darts_selected": 10,
-    "deep": 8,
+    "n_darts_selected": 25,
+    "deep": 6,
     "action_restriction": false,
     "with_degree_observation": false
 }

…nment/parameters/environment_config.json environment/environment_config.jsonenvironment/parameters/environment_config.json renamed to environment/environment_config.json environment/parameters/environment_config.json renamed to environment/environment_config.json

@@ -1,17 +1,14 @@
 from enum import Enum
 import gymnasium as gym
 from gymnasium import spaces
-import pygame
 import numpy as np
+import copy
 
 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 environment.gymnasium_envs.quadmesh_env.envs.mesh_conv import get_x
-from actions.quadrangular_actions import flip_edge, split_edge, collapse_edge, cleanup_edge
-
-from view.window import Game
-from mesh_display import MeshDisplay
+from environment.actions.quadrangular_actions import flip_edge, split_edge, collapse_edge, cleanup_edge
 
 
 class Actions(Enum):
@@ -25,7 +22,12 @@ class QuadMeshEnv(gym.Env):
     metadata = {"render_modes": ["human", "rgb_array"], "render_fps": 60}
 
     def __init__(self, mesh=None, n_darts_selected=20, deep=6, with_degree_obs=True, action_restriction=False, render_mode=None):
-        self.mesh = mesh if mesh is not None else random_mesh()
+        if mesh is not None:
+            self.config = {"mesh": mesh}
+            self.mesh = copy.deepcopy(mesh)
+        else :
+            self.config = {"mesh": None}
+            self.mesh = random_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)
@@ -40,7 +42,6 @@ def __init__(self, mesh=None, n_darts_selected=20, deep=6, with_degree_obs=True,
         self.nb_invalid_actions = 0
         self.darts_selected = [] # darts id observed
         deep = self.deep*2 if self.degree_observation else deep
-
         self.observation_space = spaces.Box(
             low=-15,  # nodes min degree : -15
             high=15,  # nodes max degree : 15
@@ -59,6 +60,8 @@ def reset(self, seed=None, options=None):
         super().reset(seed=seed)
         if options is not None:
             self.mesh = options['mesh']
+        elif self.config["mesh"] is not None:
+            self.mesh = copy.deepcopy(self.config["mesh"])
         else:
             self.mesh = random_mesh()
         self.nb_darts = len(self.mesh.dart_info)

environment/gymnasium_envs/quadmesh_env/envs/quadmesh.py

@@ -7,7 +7,7 @@
 from mesh_model.mesh_struct.mesh_elements import Dart
 from mesh_model.mesh_analysis.trimesh_analysis import global_score, isTruncated
 from environment.gymnasium_envs.trimesh_flip_env.envs.mesh_conv import get_x
-from actions.triangular_actions import flip_edge
+from environment.actions.triangular_actions import flip_edge
 
 from view.window import Game
 from mesh_display import MeshDisplay

environment/gymnasium_envs/trimesh_flip_env/envs/trimesh.py

@@ -8,7 +8,7 @@
 from mesh_model.mesh_struct.mesh_elements import Dart
 from mesh_model.mesh_analysis.trimesh_analysis import global_score, isTruncated
 from environment.gymnasium_envs.trimesh_full_env.envs.mesh_conv import get_x
-from actions.triangular_actions import flip_edge, split_edge, collapse_edge
+from environment.actions.triangular_actions import flip_edge, split_edge, collapse_edge
 
 from view.window import Game
 from mesh_display import MeshDisplay

environment/gymnasium_envs/trimesh_full_env/envs/trimesh.py

@@ -1,4 +1,4 @@
-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.trimesh_full_env.wrappers.clip_reward import ClipReward
+from environment.gymnasium_envs.trimesh_full_env.wrappers.discrete_actions import DiscreteActions
+from environment.gymnasium_envs.trimesh_full_env.wrappers.reacher_weighted_reward import ReacherRewardWrapper
+from environment.gymnasium_envs.trimesh_full_env.wrappers.relative_position import RelativePosition

environment/gymnasium_envs/trimesh_full_env/wrappers/__init__.py

@@ -1,10 +1,9 @@
-from typing import Any
 import math
 import numpy as np
-from mesh_model.mesh_analysis import global_score, find_template_opposite_node
+from mesh_model.mesh_analysis.trimesh_analysis import global_score, find_template_opposite_node
 from mesh_model.mesh_struct.mesh_elements import Dart
 from mesh_model.mesh_struct.mesh import Mesh
-from actions.triangular_actions import flip_edge, split_edge, collapse_edge
+from environment.actions.triangular_actions import flip_edge, split_edge, collapse_edge
 from mesh_model.random_trimesh import random_flip_mesh, random_mesh
 
 # possible actions
@@ -23,7 +22,7 @@ def __init__(self, mesh=None, mesh_size: int = None, max_steps: int = 50, feat:
         self.reward = 0
         self.steps = 0
         self.max_steps = max_steps
-        self.nodes_scores, self.mesh_score, self.ideal_score = global_score(self.mesh)
+        self.nodes_scores, self.mesh_score, self.ideal_score, _ = global_score(self.mesh)
         self.terminal = False
         self.feat = feat
         self.won = 0
@@ -34,7 +33,7 @@ def reset(self, mesh=None):
         self.terminal = False
         self.mesh = mesh if mesh is not None else random_mesh(self.mesh_size)
         self.size = len(self.mesh.dart_info)
-        self.nodes_scores, self.mesh_score, self.ideal_score = global_score(self.mesh)
+        self.nodes_scores, self.mesh_score, self.ideal_score, _ = global_score(self.mesh)
         self.won = 0
 
     def step(self, action):
@@ -50,7 +49,7 @@ def step(self, action):
         elif action[2] == COLLAPSE:
             collapse_edge(self.mesh, n1, n2)
         self.steps += 1
-        next_nodes_score, next_mesh_score, _ = global_score(self.mesh)
+        next_nodes_score, next_mesh_score, _, _ = global_score(self.mesh)
         self.nodes_scores = next_nodes_score
         self.reward = (self.mesh_score - next_mesh_score) * 10
         if self.steps >= self.max_steps or next_mesh_score == self.ideal_score: