ir-sim 2.3.0__tar.gz → 2.3.2__tar.gz

{ir_sim-2.3.0 → ir_sim-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: ir-sim
-Version: 2.3.0
+Version: 2.3.2
 Summary: Open-source, lightweight robot 2D simulator based on Python, specifically designed for intelligent robotics navigation and learning.
 Author-email: Han Ruihua <hanrh@connect.hku.hk>
 Project-URL: Homepage, https://github.com/hanruihua/ir-sim
@@ -39,19 +39,26 @@ Requires-Dist: pynput; extra == "all"
 
 </div>
 
-Documentation: [https://ir-sim.readthedocs.io/en](https://ir-sim.readthedocs.io/en/latest/)
+**Documentation:** [https://ir-sim.readthedocs.io/en](https://ir-sim.readthedocs.io/en/latest/)
 
 IR-SIM is an open-source, lightweight robot simulator based on Python, specifically designed for intelligent robotics navigation and learning. Primarily intended for research and educational purposes, it is user-friendly and easily customizable.
 
 It provides the following features:
-  - A versatile and easy-to-use framework for simulating a variety of robot platforms with kinematics and sensors. 
-  - Customizable configurations and parameters using yaml files.
-  - Real-time visualization of simulation outcomes.
-  - Ideal for developing and testing algorithms related to robot navigation, motion planning, reinforcement learning.
 
-|                                           Robot                                           |                                           Car                                           |
-| :---------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------: |
-| ![robot](https://github.com/user-attachments/assets/5930b088-d400-4943-8ded-853c22eae75b) | ![car](https://github.com/user-attachments/assets/3257abc1-8bed-40d8-9b51-e5d90b06ee06) |
+- **Versatile and User-Friendly Framework:** Simulate a wide range of robot platforms with diverse kinematics and sensors.
+- **Easy Configuration with YAML:** Easily set up and modify simulation scenarios using straightforward YAML files, no complex coding required for quick and flexible environment customization.
+- **Real-Time Visualization:** Visualize simulation outcomes in real time for immediate feedback and analysis.
+- **Predefined Benchmark Behaviors:** Utilize a comprehensive library of pre-defined behaviors that serve as benchmarks for evaluating and comparing algorithm performance.
+- **Ideal for Algorithm Development:** Suitable for developing and testing algorithms related to robot navigation, motion planning, optimal control, and reinforcement learning.
+
+|                                                        Scenarios                                                        |                                                                    Description                                                                    |
+| :--------------------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------: |
+| <img src="https://github.com/user-attachments/assets/5930b088-d400-4943-8ded-853c22eae75b" alt="drawing" width="280"/> | In scenarios involving multiple circular differential robots, each robot employs Reciprocal Velocity Obstacle (RVO) behavior to avoid collisions. |
+| <img src="https://github.com/user-attachments/assets/3257abc1-8bed-40d8-9b51-e5d90b06ee06" alt="drawing" width="280"/> |                   A car-like robot controlled via keyboard navigates a binary map using a 2D LiDAR sensor to detect obstacles.                    |
+| <img src="https://github.com/user-attachments/assets/7aa809c2-3a44-4377-a22d-728b9dbdf8bc" alt="drawing" width="280"/> |                                 Each robot employing RVO behavior is equipped with a field of view (FOV) to detect other robots within this area.  |
+| <img src="https://github.com/user-attachments/assets/1cc8a4a6-2f41-4bc9-bc59-a7faff443223" alt="drawing" width="280"/> |  A car-like robot navigates through the randomly generated and moving obstacles  |
+
+
 
 ## Prerequisite
 
@@ -65,6 +72,16 @@ It provides the following features:
 pip install ir-sim
 ```
 
+This does not include dependencies for all features of the simulator. To install additional optional dependencies, use the following pip commands:
+
+```
+# install dependencies for keyboard control
+pip install ir-sim[keyboard]
+
+# install all optional dependencies
+pip install ir-sim[all]  
+```
+
 - Or for development, you may install from source: 
 
 ```
@@ -118,54 +135,8 @@ robot:
 
 The advanced usages are listed in the [irsim/usage](https://github.com/hanruihua/ir-sim/tree/main/irsim/usage)
 
-
-<!-- ## YAML Configuration Example
-
-```yaml
-
-world:
-  height: 10  
-  width: 10   
-  step_time: 0.1  
-  sample_time: 0.1   
-  offset: [0, 0] 
-  collision_mode: 'stop'  # 'stop', 'unobstructed', 'reactive'
-  control_mode: 'auto'  # 'auto', 'keyboard'
-
-robot:
-  - number: 10
-    distribution: {name: 'circle', radius: 4.0, center: [5, 5]}  # name: 'circle', 'random',
-    kinematics: {name: 'diff'} # name: 'diff', 'omni', acker
-    shape: 
-      - {name: 'circle', radius: 0.2}  # name: 'circle', 'rectangle'
-    behavior: {name: 'rvo', vxmax: 1.3, vymax: 1.3, accer: 1.0, factor: 0.5} # name: 
-    vel_min: [-2, -2.0]
-    vel_max: [2, 2.0]
-    color: ['royalblue', 'red', 'green', 'orange', 'purple', 'yellow', 'cyan', 'magenta', 'lime', 'pink', 'brown'] 
-    arrive_mode: position   # position, state
-    goal_threshold: 0.15
-    plot:
-      show_trail: true
-      show_goal: true
-      trail_fill: True
-      trail_alpha: 0.2
-
-obstacle:
-  - shape: {name: 'circle', radius: 1.0}  
-    state: [5, 5, 0]  
-  
-  - number: 10
-    distribution: {name: 'manual'}
-    shape:
-      - {name: 'polygon', random_shape: true, center_range: [5, 10, 40, 30], avg_radius_range: [0.5, 2], irregularity_range: [0, 1], spikeyness_range: [0, 1], num_vertices_range: [4, 5]}  
-
-  - shape: {name: 'linestring', vertices: [[5, 5], [4, 0], [1, 6]] } 
-    state: [0, 0, 0] 
-
-``` -->
-
-## Cases
-- [rl-rvo-nav](https://github.com/hanruihua/rl_rvo_nav)(RAL & ICRA2023)
+## Academic Cases
+- [rl-rvo-nav](https://github.com/hanruihua/rl_rvo_nav) (RAL & ICRA2023)
 - [RDA_planner](https://github.com/hanruihua/RDA_planner)（RAL & IROS2023）
 
 

ir_sim-2.3.2/README.md

@@ -0,0 +1,127 @@
+<!-- <div align="center">
+<img src="doc/image/ir-sim_logos/logo1_nobg.png" width = "200" >
+</div>  -->
+
+
+<div align="center">
+
+# Intelligent Robot Simulator (IR-SIM)
+
+<a href="https://pypi.org/project/ir-sim/"><img src='https://img.shields.io/pypi/v/ir-sim?color=orange' alt='Github Release'></a>
+<a href="https://github.com/hanruihua/ir-sim?tab=MIT-1-ov-file"><img src='https://img.shields.io/badge/License-MIT-blue' alt='License'></a>
+<a href="https://pepy.tech/project/ir-sim"><img src="https://img.shields.io/pepy/dt/ir-sim" alt="PyPI Downloads"></a>
+<a href="https://codecov.io/gh/hanruihua/ir-sim" > <img src="https://codecov.io/gh/hanruihua/ir-sim/branch/dev/graph/badge.svg?token=OSC8I5QCQ0"/> </a>
+<a href="https://ir-sim.readthedocs.io/en/latest/"> <img alt="Read the Docs" src="https://img.shields.io/readthedocs/ir-sim"/> </a>
+
+</div>
+
+**Documentation:** [https://ir-sim.readthedocs.io/en](https://ir-sim.readthedocs.io/en/latest/)
+
+IR-SIM is an open-source, lightweight robot simulator based on Python, specifically designed for intelligent robotics navigation and learning. Primarily intended for research and educational purposes, it is user-friendly and easily customizable.
+
+It provides the following features:
+
+- **Versatile and User-Friendly Framework:** Simulate a wide range of robot platforms with diverse kinematics and sensors.
+- **Easy Configuration with YAML:** Easily set up and modify simulation scenarios using straightforward YAML files, no complex coding required for quick and flexible environment customization.
+- **Real-Time Visualization:** Visualize simulation outcomes in real time for immediate feedback and analysis.
+- **Predefined Benchmark Behaviors:** Utilize a comprehensive library of pre-defined behaviors that serve as benchmarks for evaluating and comparing algorithm performance.
+- **Ideal for Algorithm Development:** Suitable for developing and testing algorithms related to robot navigation, motion planning, optimal control, and reinforcement learning.
+
+|                                                        Scenarios                                                        |                                                                    Description                                                                    |
+| :--------------------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------: |
+| <img src="https://github.com/user-attachments/assets/5930b088-d400-4943-8ded-853c22eae75b" alt="drawing" width="280"/> | In scenarios involving multiple circular differential robots, each robot employs Reciprocal Velocity Obstacle (RVO) behavior to avoid collisions. |
+| <img src="https://github.com/user-attachments/assets/3257abc1-8bed-40d8-9b51-e5d90b06ee06" alt="drawing" width="280"/> |                   A car-like robot controlled via keyboard navigates a binary map using a 2D LiDAR sensor to detect obstacles.                    |
+| <img src="https://github.com/user-attachments/assets/7aa809c2-3a44-4377-a22d-728b9dbdf8bc" alt="drawing" width="280"/> |                                 Each robot employing RVO behavior is equipped with a field of view (FOV) to detect other robots within this area.  |
+| <img src="https://github.com/user-attachments/assets/1cc8a4a6-2f41-4bc9-bc59-a7faff443223" alt="drawing" width="280"/> |  A car-like robot navigates through the randomly generated and moving obstacles  |
+
+
+
+## Prerequisite
+
+- Python: >= 3.7
+
+## Installation
+
+- Install this package from PyPi:
+
+```
+pip install ir-sim
+```
+
+This does not include dependencies for all features of the simulator. To install additional optional dependencies, use the following pip commands:
+
+```
+# install dependencies for keyboard control
+pip install ir-sim[keyboard]
+
+# install all optional dependencies
+pip install ir-sim[all]  
+```
+
+- Or for development, you may install from source: 
+
+```
+git clone https://github.com/hanruihua/ir-sim.git    
+cd ir-sim   
+pip install -e .  
+```
+ 
+## Usage
+
+### Quick Start
+
+```python
+
+import irsim
+
+env = irsim.make('robot_world.yaml') # initialize the environment with the configuration file
+
+for i in range(300): # run the simulation for 300 steps
+
+    env.step()  # update the environment
+    env.render() # render the environment
+
+    if env.done(): break # check if the simulation is done
+        
+env.end() # close the environment
+```
+
+YAML Configuration: robot_world.yaml
+
+```yaml
+
+world:
+  height: 10  # the height of the world
+  width: 10   # the height of the world
+  step_time: 0.1  # 10Hz calculate each step
+  sample_time: 0.1  # 10 Hz for render and data extraction 
+  offset: [0, 0] # the offset of the world on x and y 
+
+robot:
+  kinematics: {name: 'diff'}  # omni, diff, acker
+  shape: {name: 'circle', radius: 0.2}  # radius
+  state: [1, 1, 0]  # x, y, theta
+  goal: [9, 9, 0]  # x, y, theta
+  behavior: {name: 'dash'} # move toward to the goal directly 
+  color: 'g' # green
+```
+
+
+### Advanced Usage
+
+The advanced usages are listed in the [irsim/usage](https://github.com/hanruihua/ir-sim/tree/main/irsim/usage)
+
+## Academic Cases
+- [rl-rvo-nav](https://github.com/hanruihua/rl_rvo_nav) (RAL & ICRA2023)
+- [RDA_planner](https://github.com/hanruihua/RDA_planner)（RAL & IROS2023）
+
+
+## Acknowledgement
+
+- [PythonRobotics](https://github.com/AtsushiSakai/PythonRobotics)
+
+
+
+
+
+

{ir_sim-2.3.0 → ir_sim-2.3.2}/ir_sim.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: ir-sim
-Version: 2.3.0
+Version: 2.3.2
 Summary: Open-source, lightweight robot 2D simulator based on Python, specifically designed for intelligent robotics navigation and learning.
 Author-email: Han Ruihua <hanrh@connect.hku.hk>
 Project-URL: Homepage, https://github.com/hanruihua/ir-sim
@@ -39,19 +39,26 @@ Requires-Dist: pynput; extra == "all"
 
 </div>
 
-Documentation: [https://ir-sim.readthedocs.io/en](https://ir-sim.readthedocs.io/en/latest/)
+**Documentation:** [https://ir-sim.readthedocs.io/en](https://ir-sim.readthedocs.io/en/latest/)
 
 IR-SIM is an open-source, lightweight robot simulator based on Python, specifically designed for intelligent robotics navigation and learning. Primarily intended for research and educational purposes, it is user-friendly and easily customizable.
 
 It provides the following features:
-  - A versatile and easy-to-use framework for simulating a variety of robot platforms with kinematics and sensors. 
-  - Customizable configurations and parameters using yaml files.
-  - Real-time visualization of simulation outcomes.
-  - Ideal for developing and testing algorithms related to robot navigation, motion planning, reinforcement learning.
 
-|                                           Robot                                           |                                           Car                                           |
-| :---------------------------------------------------------------------------------------: | :-------------------------------------------------------------------------------------: |
-| ![robot](https://github.com/user-attachments/assets/5930b088-d400-4943-8ded-853c22eae75b) | ![car](https://github.com/user-attachments/assets/3257abc1-8bed-40d8-9b51-e5d90b06ee06) |
+- **Versatile and User-Friendly Framework:** Simulate a wide range of robot platforms with diverse kinematics and sensors.
+- **Easy Configuration with YAML:** Easily set up and modify simulation scenarios using straightforward YAML files, no complex coding required for quick and flexible environment customization.
+- **Real-Time Visualization:** Visualize simulation outcomes in real time for immediate feedback and analysis.
+- **Predefined Benchmark Behaviors:** Utilize a comprehensive library of pre-defined behaviors that serve as benchmarks for evaluating and comparing algorithm performance.
+- **Ideal for Algorithm Development:** Suitable for developing and testing algorithms related to robot navigation, motion planning, optimal control, and reinforcement learning.
+
+|                                                        Scenarios                                                        |                                                                    Description                                                                    |
+| :--------------------------------------------------------------------------------------------------------------------: | :-----------------------------------------------------------------------------------------------------------------------------------------------: |
+| <img src="https://github.com/user-attachments/assets/5930b088-d400-4943-8ded-853c22eae75b" alt="drawing" width="280"/> | In scenarios involving multiple circular differential robots, each robot employs Reciprocal Velocity Obstacle (RVO) behavior to avoid collisions. |
+| <img src="https://github.com/user-attachments/assets/3257abc1-8bed-40d8-9b51-e5d90b06ee06" alt="drawing" width="280"/> |                   A car-like robot controlled via keyboard navigates a binary map using a 2D LiDAR sensor to detect obstacles.                    |
+| <img src="https://github.com/user-attachments/assets/7aa809c2-3a44-4377-a22d-728b9dbdf8bc" alt="drawing" width="280"/> |                                 Each robot employing RVO behavior is equipped with a field of view (FOV) to detect other robots within this area.  |
+| <img src="https://github.com/user-attachments/assets/1cc8a4a6-2f41-4bc9-bc59-a7faff443223" alt="drawing" width="280"/> |  A car-like robot navigates through the randomly generated and moving obstacles  |
+
+
 
 ## Prerequisite
 
@@ -65,6 +72,16 @@ It provides the following features:
 pip install ir-sim
 ```
 
+This does not include dependencies for all features of the simulator. To install additional optional dependencies, use the following pip commands:
+
+```
+# install dependencies for keyboard control
+pip install ir-sim[keyboard]
+
+# install all optional dependencies
+pip install ir-sim[all]  
+```
+
 - Or for development, you may install from source: 
 
 ```
@@ -118,54 +135,8 @@ robot:
 
 The advanced usages are listed in the [irsim/usage](https://github.com/hanruihua/ir-sim/tree/main/irsim/usage)
 
-
-<!-- ## YAML Configuration Example
-
-```yaml
-
-world:
-  height: 10  
-  width: 10   
-  step_time: 0.1  
-  sample_time: 0.1   
-  offset: [0, 0] 
-  collision_mode: 'stop'  # 'stop', 'unobstructed', 'reactive'
-  control_mode: 'auto'  # 'auto', 'keyboard'
-
-robot:
-  - number: 10
-    distribution: {name: 'circle', radius: 4.0, center: [5, 5]}  # name: 'circle', 'random',
-    kinematics: {name: 'diff'} # name: 'diff', 'omni', acker
-    shape: 
-      - {name: 'circle', radius: 0.2}  # name: 'circle', 'rectangle'
-    behavior: {name: 'rvo', vxmax: 1.3, vymax: 1.3, accer: 1.0, factor: 0.5} # name: 
-    vel_min: [-2, -2.0]
-    vel_max: [2, 2.0]
-    color: ['royalblue', 'red', 'green', 'orange', 'purple', 'yellow', 'cyan', 'magenta', 'lime', 'pink', 'brown'] 
-    arrive_mode: position   # position, state
-    goal_threshold: 0.15
-    plot:
-      show_trail: true
-      show_goal: true
-      trail_fill: True
-      trail_alpha: 0.2
-
-obstacle:
-  - shape: {name: 'circle', radius: 1.0}  
-    state: [5, 5, 0]  
-  
-  - number: 10
-    distribution: {name: 'manual'}
-    shape:
-      - {name: 'polygon', random_shape: true, center_range: [5, 10, 40, 30], avg_radius_range: [0.5, 2], irregularity_range: [0, 1], spikeyness_range: [0, 1], num_vertices_range: [4, 5]}  
-
-  - shape: {name: 'linestring', vertices: [[5, 5], [4, 0], [1, 6]] } 
-    state: [0, 0, 0] 
-
-``` -->
-
-## Cases
-- [rl-rvo-nav](https://github.com/hanruihua/rl_rvo_nav)(RAL & ICRA2023)
+## Academic Cases
+- [rl-rvo-nav](https://github.com/hanruihua/rl_rvo_nav) (RAL & ICRA2023)
 - [RDA_planner](https://github.com/hanruihua/RDA_planner)（RAL & IROS2023）
 
 

{ir_sim-2.3.0 → ir_sim-2.3.2}/ir_sim.egg-info/SOURCES.txt

@@ -65,8 +65,13 @@ irsim/usage/14world_3d_plot/robot_omni_world.yaml
 irsim/usage/14world_3d_plot/robot_polygon_world.yaml
 irsim/usage/14world_3d_plot/robot_world_3d.py
 irsim/usage/14world_3d_plot/robot_world_3d.yaml
+irsim/usage/15fov_world/fov_world.py
+irsim/usage/15fov_world/fov_world.yaml
+irsim/usage/16noise_world/noise_world.py
+irsim/usage/16noise_world/noise_world.yaml
 irsim/util/util.py
 irsim/world/__init__.py
+irsim/world/arm_base.py
 irsim/world/object_base.py
 irsim/world/object_base_3d.py
 irsim/world/object_factory.py
@@ -84,6 +89,7 @@ irsim/world/obstacles/obstacle_diff.py
 irsim/world/obstacles/obstacle_omni.py
 irsim/world/obstacles/obstacle_static.py
 irsim/world/robots/robot_acker.py
+irsim/world/robots/robot_arm.py
 irsim/world/robots/robot_diff.py
 irsim/world/robots/robot_omni.py
 irsim/world/robots/robot_rigid3d.py

{ir_sim-2.3.0 → ir_sim-2.3.2}/irsim/env/env_base.py

@@ -25,10 +25,12 @@ from tabulate import tabulate
 
 try:
     from pynput import keyboard
+
     keyboard_module = True
 except ImportError:
     keyboard_module = False
 
+
 class EnvBase:
     """
     The base class of environment. This class will read the yaml file and create the world, robot, obstacle, and map objects.
@@ -118,7 +120,7 @@ class EnvBase:
     def __str__(self):
         return f"Environment: {self._world.name}"
 
-    def step(self, action=None, action_id=0):
+    def step(self, action: Optional[np.ndarray] = None, action_id=0):
         """
         Perform a simulation step in the environment.
 
@@ -142,16 +144,16 @@ class EnvBase:
 
         self._world.step()
 
-    def _objects_step(self, action=None):
+    def _objects_step(self, action: Optional[list] =None):
         action = action + [None] * (len(self.objects) - len(action))
         [obj.step(action) for obj, action in zip(self.objects, action)]
 
-    def _object_step(self, action, obj_id=0):
+    def _object_step(self, action: np.ndarray, obj_id: int = 0):
         self.objects[obj_id].step(action)
         [obj.step() for obj in self.objects if obj._id != obj_id]
 
     # render
-    def render(self, interval=0.05, figure_kwargs=dict(), **kwargs):
+    def render(self, interval: float =0.05, figure_kwargs=dict(), **kwargs):
         """
         Render the environment.
 
@@ -199,12 +201,13 @@ class EnvBase:
 
         Args:
             points (list): List of points (2*1) to be drawn.
+                or (np.array): (2, Num) to be drawn.
             s (int): Size of the points.
             c (str): Color of the points.
             refresh (bool): Flag to refresh the points in the figure.
             **kwargs: Additional keyword arguments for drawing the points, see `ax.scatter <https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.scatter.html>`_ function for detail.
         """
-
+        
         self._env_plot.draw_points(points, s, c, refresh, **kwargs)
 
     def draw_box(self, vertex, refresh=True, color="-b"):
@@ -282,7 +285,7 @@ class EnvBase:
             ["r", "reset the environment"],
         ]
         # headers = ["key", "function"]
-        
+
         headers = ["Key", "Function"]
         # Generate the table using tabulate
         table = tabulate(commands, headers=headers, tablefmt="grid")
@@ -484,7 +487,7 @@ class EnvBase:
 
         return self.robot_list[id].get_lidar_offset()
 
-    def get_obstacle_list(self):
+    def get_obstacle_info_list(self):
         """
         Get the information of the obstacles in the environment.
 

{ir_sim-2.3.0 → ir_sim-2.3.2}/irsim/env/env_plot.py

@@ -39,6 +39,7 @@ class EnvPlot:
         saved_ani=dict(),
         dpi: int = 100,
         figure_pixels: list =[1920, 1080],
+        
         **kwargs,
     ) -> None:
         """
@@ -205,25 +206,39 @@ class EnvPlot:
         if refresh:
             self.dyna_line_list.append(line)
 
-    def draw_points(self, point_list, s=10, c="m", refresh=True, **kwargs):
+    def draw_points(self, points, s=10, c="m", refresh=True, **kwargs):
         """
         Draw points on the plot.
 
         Args:
-            point_list (list): List of points, each point as [x, y].
+            points (list): List of points, each point as [x, y] or (2, 1) array
+                or (np.array): points array: (2, N), NL number of points
             s (int): Size of the points.
             c (str): Color of the points.
             refresh (bool): Whether to refresh the plot.
             kwargs: Additional plotting options.
         """
-        if point_list is not None:
-            x_coordinates = [point[0] for point in point_list]
-            y_coordinates = [point[1] for point in point_list]
 
-            points = self.ax.scatter(x_coordinates, y_coordinates, s, c, **kwargs)
+        if points is None:
+            return
 
-            if refresh:
-                self.dyna_point_list.append(points)
+        if isinstance(points, list):
+            x_coordinates = [point[0] for point in points]
+            y_coordinates = [point[1] for point in points]
+
+        elif isinstance(points, np.ndarray):
+
+            if points.shape[1] > 1:
+                x_coordinates = [point[0] for point in points.T]
+                y_coordinates = [point[1] for point in points.T]
+            else:
+                x_coordinates = points[0]
+                y_coordinates = points[1]
+
+        points_plot = self.ax.scatter(x_coordinates, y_coordinates, s, c, **kwargs)
+
+        if refresh:
+            self.dyna_point_list.append(points_plot)
 
     def draw_box(self, vertices, refresh=False, color="b-"):
         """

ir_sim-2.3.2/irsim/env/env_plot3d.py

@@ -0,0 +1,125 @@
+from .env_plot import EnvPlot
+import mpl_toolkits.mplot3d.art3d as art3d
+from mpl_toolkits.mplot3d import Axes3D
+import numpy as np
+import matplotlib.pyplot as plt
+from math import cos, sin
+
+class EnvPlot3D(EnvPlot):
+
+    def __init__(
+        self,grid_map=None,
+        objects=[],
+        x_range=[0, 10],
+        y_range=[0, 10],
+        z_range=[0, 10],
+        saved_figure=dict(),
+        saved_ani=dict(),
+        dpi: int = 100,
+        figure_pixels: list =[1920, 1080],
+        **kwargs,
+    ):
+        super().__init__(grid_map, objects, x_range, y_range, saved_figure, saved_ani, dpi, figure_pixels, **kwargs)
+        
+        self.clear_components()
+        self.ax.remove()
+
+        self.ax = self.fig.add_subplot(projection='3d')
+        self.z_range = z_range
+
+        self.init_plot(grid_map, objects, **kwargs)
+        self.ax.set_zlim(z_range)
+
+
+    def draw_points(self, points, s=10, c="m", refresh=True, **kwargs):
+        """
+        Draw points on the plot.
+
+        Args:
+            points (list): List of points, each point as [x, y, z].
+            s (int): Size of the points.
+            c (str): Color of the points.
+            refresh (bool): Whether to refresh the plot.
+            kwargs: Additional plotting options.
+        """
+
+        if points is None:
+            return
+
+        if isinstance(points, list):
+            x_coordinates = [point[0] for point in points]
+            y_coordinates = [point[1] for point in points]
+            z_coordinates = [point[2] for point in points]
+
+        elif isinstance(points, np.ndarray):
+
+            if points.shape[1] > 1:
+                x_coordinates = [point[0] for point in points.T]
+                y_coordinates = [point[1] for point in points.T]
+                z_coordinates = [point[2] for point in points.T]
+            else:
+                x_coordinates = points[0]
+                y_coordinates = points[1]
+                z_coordinates = points[2]
+
+    
+        points = self.ax.scatter(x_coordinates, y_coordinates, z_coordinates, 'z', s, c, **kwargs)
+
+        if refresh:
+            self.dyna_point_list.append(points)
+
+    def draw_trajectory(
+        self,
+        traj,
+        traj_type="g-",
+        label="trajectory",
+        show_direction=False,
+        refresh=False,
+        **kwargs,
+    ):
+        """
+        Draw a trajectory on the plot.
+
+        Args:
+            traj (list or np.ndarray): List of points or array of points [x, y, z].
+            traj_type (str): Type of trajectory line (e.g., 'g-').
+                See https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.plot.html for details.
+            label (str): Label for the trajectory.
+            show_direction (bool): Whether to show the direction of the trajectory.
+            refresh (bool): Whether to refresh the plot.
+            kwargs: Additional plotting options for ax.plot()
+        """
+        if isinstance(traj, list):
+            path_x_list = [p[0, 0] for p in traj]
+            path_y_list = [p[1, 0] for p in traj]
+            path_z_list = [p[2, 0] for p in traj]
+        elif isinstance(traj, np.ndarray):
+            path_x_list = [p[0] for p in traj.T]
+            path_y_list = [p[1] for p in traj.T]
+            path_z_list = [p[2] for p in traj.T]
+
+        line = self.ax.plot(path_x_list, path_y_list, path_z_list, traj_type, label=label, **kwargs)
+
+        if show_direction:
+            print('Not support currently')
+            # if isinstance(traj, list):
+            #     u_list = [cos(p[2, 0]) for p in traj]
+            #     v_list = [sin(p[2, 0]) for p in traj]
+            # elif isinstance(traj, np.ndarray):
+            #     u_list = [cos(p[2]) for p in traj.T]
+            #     v_list = [sin(p[2]) for p in traj.T]
+
+            # if isinstance(self.ax, Axes3D):
+            #     path_z_list = [0] * len(path_x_list)
+            #     w_list = [0] * len(u_list)
+
+            #     self.ax.quiver(path_x_list, path_y_list, path_z_list, u_list, v_list, w_list)
+            
+            # else:
+            #     self.ax.quiver(path_x_list, path_y_list, u_list, v_list)
+
+        if refresh:
+            self.dyna_line_list.append(line)
+
+
+

{ir_sim-2.3.0 → ir_sim-2.3.2}/irsim/lib/algorithm/generation.py

@@ -82,7 +82,7 @@ def generate_polygon(center, avg_radius, irregularity, spikeyness, num_vertices)
     angle_steps = random_angle_steps(num_vertices, irregularity)
 
     points = []
-    angle = random.uniform(0, 2 * math.pi)
+    angle = np.random.uniform(0, 2 * math.pi)
     for i in range(num_vertices):
         radius = clip(random.gauss(avg_radius, spikeyness), 0, 2 * avg_radius)
         point = (
@@ -113,7 +113,7 @@ def random_angle_steps(steps: int, irregularity: float) -> List[float]:
     upper = (2 * math.pi / steps) + irregularity
     cumsum = 0
     for i in range(steps):
-        angle = random.uniform(lower, upper)
+        angle = np.random.uniform(lower, upper)
         angles.append(angle)
         cumsum += angle