[ENVS] Envs updates

sofagym/ServerEnv.py

@@ -0,0 +1,168 @@
+# -*- coding: utf-8 -*-
+"""ServerEnv to use the server-client architecture.
+"""
+
+__authors__ = ("PSC", "dmarchal", "emenager")
+__contact__ = ("[email protected]", "[email protected]", "[email protected]")
+__version__ = "1.0.0"
+__copyright__ = "(c) 2020, Robocath, CNRS, Inria"
+__date__ = "Oct 7 2020"
+
+from typing import Optional
+
+import numpy as np
+import copy
+
+import splib3
+
+from sofagym.rpc_server import start_server, add_new_step, get_result, clean_registry, close_scene
+
+from sofagym.AbstractEnv import AbstractEnv
+
+
+class ServerEnv(AbstractEnv):
+    def __init__(self, default_config, config=None, render_mode: Optional[str]=None, root=None):
+        super().__init__(default_config, config, root=root)
+
+        # Start the server which distributes the calculations to its clients
+        start_server(self.config)
+
+    def step(self, action):
+        """Executes one action in the environment.
+
+        Apply action and execute scale_factor simulation steps of 0.01 s.
+
+        Parameters:
+        ----------
+            action: int
+                Action applied in the environment.
+
+        Returns:
+        -------
+            obs(ObsType):
+                The new state of the agent.
+            reward(float):
+                The reward obtain after applying the action in the current state.
+            done(bool):
+                Whether the agent reaches the terminal state
+            info(dict): 
+                additional information (not used here)
+        """
+        # assert self.action_space.contains(action), "%r (%s) invalid" % (action, type(action))
+
+        action = self._formataction(action)
+
+        # Pass the actions to the server to launch the simulation.
+        result_id = add_new_step(self.past_actions, action)
+        self.past_actions.append(action)
+
+        # Request results from the server.
+        # print("[INFO]   >>> Result id:", result_id)
+        results = get_result(result_id, timeout=self.timeout)
+
+        obs = np.array(results["observation"])  # to work with baseline
+        reward = results["reward"]
+        done = results["done"]
+
+        # Avoid long explorations by using a timer.
+        self.timer += 1
+        if self.timer >= self.config["timer_limit"]:
+            # reward = -150
+            truncated = True
+
+        info = {} #(not use here)
+
+        if self.config["planning"]:
+            self.clean()
+        return obs, reward, done, info
+
+    def async_step(self, action):
+        """Executes one action in the environment.
+
+        Apply action and execute scale_factor simulation steps of 0.01 s.
+        Like step but useful if you want to parallelise (blocking "get").
+        Otherwise use step.
+
+        Parameters:
+        ----------
+            action: int
+                Action applied in the environment.
+
+        Returns:
+        -------
+            LateResult:
+                Class which allows to store the id of the client who performs
+                the calculation and to return later the usual information
+                (observation, reward, done) thanks to a get method.
+
+        """
+        assert self.action_space.contains(action), "%r (%s) invalid" % (action, type(action))
+
+        result_id = add_new_step(self.past_actions, action)
+        self.past_actions.append(action)
+
+        class LateResult:
+            def __init__(self, result_id):
+                self.result_id = result_id
+
+            def get(self, timeout=None):
+                results = get_result(self.result_id, timeout=timeout)
+                obs = results["observation"]
+                reward = results["reward"]
+                done = results["done"]
+                return obs, reward, done, {}
+
+        return LateResult(copy.copy(result_id))
+
+    def reset(self):
+        """Reset simulation.
+
+        Parameters:
+        ----------
+            None.
+
+        Returns:
+        -------
+            obs, info
+        """
+        self.clean()
+        self.viewer = None
+
+        splib3.animation.animate.manager = None
+
+        self.timer = 0
+        self.past_actions = []
+
+        return
+
+    def clean(self):
+        """Function to clean the registery .
+
+        Close clients who are processing unused sequences of actions (for
+        planning)
+
+        Parameters:
+        ----------
+            None.
+
+        Returns:
+        -------
+            None.
+        """
+        clean_registry(self.past_actions)
+
+    def close(self):
+        """Terminate simulation.
+
+        Close the viewer and the scene.
+
+        Parametres:
+        ----------
+            None.
+
+        Returns:
+        -------
+            None.
+        """
+        super().close()
+        close_scene()

sofagym/envs/BubbleMotion/BubbleMotionEnv.py

@@ -9,24 +9,29 @@
 __date__ = "Feb 3 2021"
 
 from sofagym.AbstractEnv import AbstractEnv
+from sofagym.ServerEnv import 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 +51,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