[ENVS] Envs updates

sofagym/envs/BubbleMotion/BubbleMotionEnv.py

@@ -8,25 +8,29 @@
 __copyright__ = "(c) 2021, Inria"
 __date__ = "Feb 3 2021"
 
-from sofagym.AbstractEnv import AbstractEnv
+from sofagym.AbstractEnv import AbstractEnv, ServerEnv
 from sofagym.rpc_server import start_scene
 
 from gym import spaces
 import os, sys
 import numpy as np
 
-class BubbleMotionEnv(AbstractEnv):
+from typing import Optional
+
+class BubbleMotionEnv:
     """Sub-class of AbstractEnv, dedicated to the gripper scene.
 
     See the class AbstractEnv for arguments and methods.
     """
     #Setting a default configuration
     path = os.path.dirname(os.path.abspath(__file__))
     metadata = {'render.modes': ['human', 'rgb_array']}
+    dim_state = 15
     DEFAULT_CONFIG = {"scene": "BubbleMotion",
                       "deterministic": True,
                       "source": [5, -5, 20],
                       "target": [5, 5, 0],
+                      "goal": True,
                       "goalList": [[7, 0, 20]],
                       "start_node": None,
                       "scale_factor": 20,
@@ -46,55 +50,69 @@ class BubbleMotionEnv(AbstractEnv):
                       "seed": None,
                       "dt": 0.01,
                       "max_pressure": 40,
-                      "board_dim": 8
+                      "board_dim": 8,
+                      "nb_actions": -1,
+                      "dim_state": dim_state,
+                      "randomize_states": False,
+                      "init_states": [0] * dim_state,
+                      "use_server": False
                       }
-
-    def __init__(self, config = None):
-        super().__init__(config)
-        nb_actions = -1
+
+    def __init__(self, config = None, root=None, use_server: Optional[bool]=None):
+        if use_server is not None:
+            self.DEFAULT_CONFIG.update({'use_server': use_server})
+        self.use_server = self.DEFAULT_CONFIG["use_server"]
+        self.env = ServerEnv(self.DEFAULT_CONFIG, config, root=root) if self.use_server else AbstractEnv(self.DEFAULT_CONFIG, config, root=root)
+
+        self.initialize_states()
+
+        if self.env.config["goal"]:
+            self.init_goal()
+
         low = np.array([-1]*9)
         high = np.array([1]*9)
-        self.action_space = spaces.Box(low=low, high=high, shape=(9,), dtype='float32')
-        self.nb_actions = str(nb_actions)
-
-        dim_state = 15
-        low_coordinates = np.array([0]*dim_state)
-        high_coordinates = np.array([80]*dim_state)
-        self.observation_space = spaces.Box(low_coordinates, high_coordinates,
-                                            dtype='float32')
-
-
-    def step(self, action):
-        return super().step(action)
-
+        self.env.action_space = spaces.Box(low=low, high=high, shape=(9,), dtype=np.float32)
+        self.nb_actions = str(self.env.nb_actions)
+
+        low_coordinates = np.array([0]*self.env.dim_state)
+        high_coordinates = np.array([80]*self.env.dim_state)
+        self.env.observation_space = spaces.Box(low_coordinates, high_coordinates, dtype=np.float32)
+
+        if self.env.root is None and not self.use_server:
+            self.env.init_root()
+
+    # called when an attribute is not found:
+    def __getattr__(self, name):
+        # assume it is implemented by self.instance
+        return self.env.__getattribute__(name)
+
+    def initialize_states(self):
+        self.env.initialize_states()
+
+        bd = self.env.config["board_dim"]
+        init_pos = [4+(bd-4)*self.env.np_random.random(), 4+(bd-4)*self.env.np_random.random(), 5]
+        self.env.config.update({'init_pos': init_pos})
+
+    def init_goal(self):
+        bd = self.env.config["board_dim"]
+        pos_goal = [1+bd*self.env.np_random.random(), 1+bd*self.env.np_random.random(), 2]
+        self.env.goal = pos_goal
+        self.env.config.update({'goalPos': self.env.goal})
+
     def reset(self):
         """Reset simulation.
-
-        Note:
-        ----
-            We launch a client to create the scene. The scene of the program is
-            client_<scene>Env.py.
-
         """
-        super().reset()
-
-        self.config.update({'goalPos': self.goal})
-        obs = start_scene(self.config, self.nb_actions)
+        self.initialize_states()
 
-        return np.array(obs['observation'])
-
-    def get_available_actions(self):
-        """Gives the actions available in the environment.
-
-        Parameters:
-        ----------
-            None.
-
-        Returns:
-        -------
-            list of the action available in the environment.
-        """
-        return self.action_space
-
-
+        if self.env.config["goal"]:
+            self.init_goal()
+
+        self.env.reset()
 
+        if self.use_server:
+            obs = start_scene(self.env.config, self.nb_actions)
+            state = np.array(obs['observation'], dtype=np.float32)
+        else:
+            state = np.array(self.env._getState(self.env.root), dtype=np.float32)
+
+        return state

sofagym/envs/BubbleMotion/BubbleMotionScene.py

@@ -45,6 +45,7 @@ def createScene(rootNode, config={"source": [5, -5, 20],
                                   "zFar":4000,
                                   "dt": 0.01,
                                   "max_pressure": 40,
+                                  "init_pos": [5, 5, 5],
                                   "board_dim": 8},
                 mode='simu_and_visu'):
 
@@ -56,10 +57,10 @@ def createScene(rootNode, config={"source": [5, -5, 20],
     visu(rootNode, config, position_spot, direction_spot, cutoff=250)
 
     bd = config["board_dim"]
-    pos_goal = [1+bd*np.random.random(), 1+bd*np.random.random(), 2]
+    pos_goal = config["goalPos"]
     add_goal_node(rootNode, pos_goal)
 
-    init_pos = [4+(bd-4)*np.random.random(), 4+(bd-4)*np.random.random(), 5]
+    init_pos = config["init_pos"]
     bubblemotion_config = {'init_pos': init_pos, "dt": config["dt"], "max_pressure": config["max_pressure"]}
 
     bubblemotion = BubbleMotion(bubblemotion_config=bubblemotion_config)

sofagym/envs/BubbleMotion/BubbleMotionToolbox.py

@@ -83,7 +83,7 @@ def getReward(self):
 
         return r, dist
 
-    def update(self):
+    def update(self, goal=None):
         """Update function.
 
         This function is used as an initialization function.
@@ -97,6 +97,7 @@ def update(self):
             None.
 
         """
+        self.goal = goal[:2]
         current_sphere_pos = self._getSpherePos()
         self.init_goal_dist = float(np.linalg.norm(current_sphere_pos-self.goal))
 
@@ -158,8 +159,8 @@ def __init__(self, *args, **kwargs):
         if 'goalPos' in kwargs:
             self.goalPos = kwargs["goalPos"]
 
-    def update(self):
-        pass
+    def update(self, goal):
+        self.goalPos = goal
 
     def set_mo_pos(self, goal):
         pass

sofagym/envs/CTR/CTREnv.py

@@ -8,24 +8,27 @@
 __copyright__ = "(c) 2021, Robocath, CNRS, Inria"
 __date__ = "Dec 01 2021"
 
-from sofagym.AbstractEnv import AbstractEnv
+from sofagym.AbstractEnv import AbstractEnv, ServerEnv
 from sofagym.rpc_server import start_scene
 from sofagym.viewer import LegacyViewer
 from sofagym.envs.CTR.CTRToolbox import startCmd
 
 from gym import spaces
-import os
+import os, sys
 import numpy as np
 
+from typing import Optional
 
-class ConcentricTubeRobotEnv(AbstractEnv):
+
+class ConcentricTubeRobotEnv:
     """Sub-class of AbstractEnv, dedicated to the trunk scene.
 
     See the class AbstractEnv for arguments and methods.
     """
     # Setting a default configuration
     path = os.path.dirname(os.path.abspath(__file__))
     metadata = {'render.modes': ['human', 'rgb_array']}
+    dim_state = 12
     DEFAULT_CONFIG = {"scene": "CTR",
                       "deterministic": True,
                       "source": [-150, 0, 30],
@@ -34,6 +37,7 @@ class ConcentricTubeRobotEnv(AbstractEnv):
                       "scale": 30,
                       "rotation": [140.0, 0.0, 0.0],
                       "translation": [0.0, 0.0, 0.0],
+                      "goal": True,
                       "goalList": [[0.0, 0.0, 0.0]],
                       "goalPos": [0.0, 0.0, 0.0],
                       "scale_factor": 10,
@@ -47,88 +51,64 @@ class ConcentricTubeRobotEnv(AbstractEnv):
                       "discrete": True,
                       "seed": 0,
                       "start_from_history": None,
-                      "python_version": "python3.8",
+                      "python_version": sys.version,
                       "zFar": 5000,
-                      "dt": 0.01
+                      "dt": 0.01,
+                      "nb_actions": 12,
+                      "dim_state": dim_state,
+                      "randomize_states": False,
+                      "init_states": [0] * dim_state,
+                      "use_server": False
                       }
 
-    def __init__(self, config=None):
-        super().__init__(config)
-        nb_actions = 12
-        self.action_space = spaces.Discrete(nb_actions)
-        self.nb_actions = str(nb_actions)
-
-        dim_state = 12
-        low_coordinates = np.array([-1]*dim_state)
-        high_coordinates = np.array([1]*dim_state)
-        self.observation_space = spaces.Box(low_coordinates, high_coordinates,
-                                            dtype='float32')
+    def __init__(self, config = None, root=None, use_server: Optional[bool]=None):
+        if use_server is not None:
+            self.DEFAULT_CONFIG.update({'use_server': use_server})
+        self.use_server = self.DEFAULT_CONFIG["use_server"]
+        self.env = ServerEnv(self.DEFAULT_CONFIG, config, root=root) if self.use_server else AbstractEnv(self.DEFAULT_CONFIG, config, root=root)
 
-        self.default_action = 3
+        self.initialize_states()
 
-    def step(self, action):
-        if self.viewer:
-            self.viewer.step(action)
+        if self.env.config["goal"]:
+            self.init_goal()
 
-        return super().step(action)
-
-    def reset(self):
-        """Reset simulation.
-
-        Note:
-        ----
-            We launch a client to create the scene. The scene of the program is
-            client_<scene>Env.py.
-
-        """
-        super().reset()
+        self.env.action_space = spaces.Discrete(self.env.nb_actions)
+        self.nb_actions = str(self.env.nb_actions)
 
-        y = -20 + 50 * np.random.random()
+        low_coordinates = np.array([-1]*self.env.dim_state)
+        high_coordinates = np.array([1]*self.env.dim_state)
+        self.env.observation_space = spaces.Box(low_coordinates, high_coordinates, dtype=np.float32)
 
-        self.goal = [0.0, y, abs(y) + 30 * np.random.random()]
-
-        self.config.update({'goalPos': self.goal})
-        obs = start_scene(self.config, self.nb_actions)
-        if self.viewer:
-            self.viewer.reset()
-
-        self.step(0)
-        self.step(4)
-        self.step(8)
-
-        return np.array(obs['observation'])
+        self.default_action = 3
 
-    def render(self, mode='rgb_array'):
-        """See the current state of the environment.
+        if self.env.root is None and not self.use_server:
+            self.env.init_root()
 
-        Get the OpenGL Context to render an image (snapshot) of the simulation
-        state.
+    # called when an attribute is not found:
+    def __getattr__(self, name):
+        # assume it is implemented by self.instance
+        return self.env.__getattribute__(name)
 
-        Parameters:
-        ----------
-          mode: string, default = 'rgb_array'
-              Type of representation.
+    def init_goal(self):
+        # Set a new random goal from the list
+        y = -20 + 50 * self.env.np_random.random()
+        self.env.goal = [0.0, y, abs(y) + 30 * self.env.np_random.random()]
+        self.env.config.update({'goalPos': self.env.goal})
 
-        Returns:
-        -------
-          None.
+    def reset(self):
+        """Reset simulation.
         """
-        if not self.viewer:
-            display_size = self.config["display_size"]  # Sim display
-            self.viewer = LegacyViewer(self, display_size, startCmd=startCmd)
+        self.initialize_states()
 
-        # Use the viewer to display the environment.
-        self.viewer.render()
+        if self.env.config["goal"]:
+            self.init_goal()
 
-    def get_available_actions(self):
-        """Gives the actions available in the environment.
+        self.env.reset()
 
-        Parameters:
-        ----------
-            None.
-
-        Returns:
-        -------
-            list of the action available in the environment.
-        """
-        return list(range(int(self.nb_actions)))
+        if self.use_server:
+            obs = start_scene(self.env.config, self.nb_actions)
+            state = np.array(obs['observation'], dtype=np.float32)
+        else:
+            state = np.array(self.env._getState(self.env.root), dtype=np.float32)
+
+        return state

sofagym/envs/CTR/CTRScene.py

@@ -186,6 +186,7 @@ def add_geometry(root, config, mode_simu=True, mode_visu=True):
                   "rotation": [140.0, 0.0, 0.0],
                   "translation": [0.0, 0.0, 0.0],
                   "goalList": [[0.0, 0.0, 10.0]],
+                  "goalPos": [0.0, 0.0, 0.0],
                   "scale_factor": 10,
                   "timer_limit": 50,
                   "timeout": 30,