Update Core.Rendering package.

Author: RobinEnjalbert

examples/Core/rendering/README.md

@@ -6,7 +6,7 @@ It is recommended to inspect and run the python scripts following this order:
 
 * ``visualization.py``: discover all visual object types (how to create and update them).
 * ``replay.py``: how to replay a simulation from a *Database*.
-* ``<backend>_offscreen.py``: an example of offscreen rendering.
+* ``offscreen.py``: an example of off-screen rendering.
 * ``several_factories.py``: how to manage several *Factories* with a single *Visualizer*.
 
 Run the examples using ``python3 <example_name>.py <backend>`` with backend being either 'vedo' (by default) or 'open3d'.

examples/Core/rendering/offscreen.py

@@ -2,48 +2,51 @@
 from numpy.random import random
 from sys import argv
 
-from SSD.Core import UserAPI, Replay
+from SSD.Core.Rendering import UserAPI, Replay
 
 # 1. Create the visualization API
-factory = UserAPI(database_name='offscreen',
+factory = UserAPI(database_dir='my_databases',
+                  database_name='offscreen',
                   remove_existing=True)
 
 # 2. Create the object to render
-armadillo = Mesh('armadillo.obj')
+mesh = Mesh('armadillo.obj').compute_normals()
 
 # 3. Add objects to the Visualizer
 # 3.1. Add a Mesh (object_id = 0)
-factory.add_mesh(positions=armadillo.points(),
-                 cells=armadillo.cells(),
+factory.add_mesh(positions=mesh.vertices,
+                 cells=mesh.cells,
                  at=0,
                  alpha=0.8,
                  c='orange6',
                  wireframe=False,
                  line_width=0.)
 # 3.2. Add a PointCloud (object_id = 1)
-factory.add_points(positions=armadillo.points(),
+factory.add_points(positions=mesh.vertices,
                    at=1,
                    point_size=5,
-                   scalar_field=armadillo.points()[:, 1])
+                   scalar_field=mesh.vertices[:, 1])
 
 # 4. Initialize the visualization
 factory.launch_visualizer(offscreen=True)
 
 # 5. Run a few steps
 print('Running offscreen...')
 for step in range(100):
-    updated_armadillo = armadillo.clone().points(armadillo.points() + 0.1 * random(armadillo.points().shape))
+    updated_mesh = mesh.clone()
+    updated_mesh.vertices = mesh.vertices + 0.1 * random(mesh.vertices.shape)
     # 5.1. Update the Mesh
     factory.update_mesh(object_id=0,
-                        positions=updated_armadillo.points())
+                        positions=updated_mesh.vertices)
     # 5.2. Update the PointCloud
     factory.update_points(object_id=1,
-                          positions=updated_armadillo.points())
+                          positions=updated_mesh.vertices)
     # 5.3. Call a rendering step
     factory.render()
 
 # 6. Close the visualization, replay steps
 print('...then replay.')
 factory.close()
-Replay(database_name='offscreen',
+Replay(database_dir='my_databases',
+       database_name='offscreen',
        backend='vedo' if len(argv) == 1 else argv[1]).launch()

examples/Core/rendering/replay.py

@@ -1,12 +1,14 @@
 from os.path import exists
+from os import system
 from sys import argv
 
-from SSD.Core import Replay
+from SSD.Core.Rendering import Replay
 
 # Check Database existence
-if not exists('visualization.db'):
-    raise FileNotFoundError("You must create the Database using `python3 visualization.py` before to replay it.")
+if not exists('my_databases/visualization.db'):
+    system('python3 visualization.py')
 
 # Launch replay
-Replay(database_name='visualization',
+Replay(database_dir='my_databases',
+       database_name='visualization',
        backend='vedo' if len(argv) == 1 else argv[1]).launch()

examples/Core/rendering/several_factories.py

@@ -3,7 +3,8 @@
 from threading import Thread
 from sys import argv
 
-from SSD.Core import Database, UserAPI, Visualizer
+from SSD.Core.Storage import Database
+from SSD.Core.Rendering import UserAPI, Visualizer
 
 
 class Simulation:
@@ -13,12 +14,12 @@ def __init__(self,
                  idx_instance: int):
 
         # Create the Mesh object
-        self.armadillo = Mesh('armadillo.obj')
+        self.mesh = Mesh('armadillo.obj')
         # Create a Factory and add the Mesh object
         self.factory = UserAPI(database=database,
                                idx_instance=idx_instance)
-        self.factory.add_mesh(positions=self.armadillo.points(),
-                              cells=self.armadillo.cells(),
+        self.factory.add_mesh(positions=self.mesh.vertices,
+                              cells=self.mesh.cells,
                               at=idx_instance,
                               c='orange3' if idx_instance == 0 else 'blue3')
 
@@ -30,7 +31,7 @@ def connect_to_visualizer(self):
     def step(self):
 
         # Update the Mesh positions
-        updated_positions = self.armadillo.points() + 0.1 * random(self.armadillo.points().shape)
+        updated_positions = self.mesh.vertices + 0.1 * random(self.mesh.vertices.shape)
         self.factory.update_mesh(object_id=0,
                                  positions=updated_positions)
         self.factory.render()
@@ -44,7 +45,8 @@ def close(self):
 if __name__ == '__main__':
 
     # 1. Create a new Database
-    db = Database(database_name='several_factories').new(remove_existing=True)
+    db = Database(database_dir='my_databases',
+                  database_name='several_factories').new(remove_existing=True)
 
     # 2. Create several simulations
     nb_simu = 2
@@ -54,6 +56,7 @@ def close(self):
     # 3. Connect a single Visualizer to the Factories
     # 3.1. Create a new Visualizer
     Visualizer.launch(backend='vedo' if len(argv) == 1 else argv[1],
+                      database_dir='my_databases',
                       database_name='several_factories',
                       nb_clients=nb_simu)
     # 3.2. Connect each Factory to the Visualizer (must be launched in thread)

examples/Core/rendering/several_factories_offscreen.py

@@ -2,7 +2,8 @@
 from numpy.random import random
 from sys import argv
 
-from SSD.Core import Database, UserAPI, Replay
+from SSD.Core.Storage import Database
+from SSD.Core.Rendering import UserAPI, Replay
 
 
 class Simulation:
@@ -12,12 +13,12 @@ def __init__(self,
                  idx_instance: int):
 
         # Create the Mesh object
-        self.armadillo = Mesh('armadillo.obj')
+        self.mesh = Mesh('armadillo.obj')
         # Create a Factory and add the Mesh object
         self.factory = UserAPI(database=database,
                                idx_instance=idx_instance)
-        self.factory.add_mesh(positions=self.armadillo.points(),
-                              cells=self.armadillo.cells(),
+        self.factory.add_mesh(positions=self.mesh.vertices,
+                              cells=self.mesh.cells,
                               at=idx_instance,
                               c='orange3' if idx_instance == 0 else 'blue3')
 
@@ -29,7 +30,7 @@ def connect_to_visualizer(self):
     def step(self):
 
         # Update the Mesh positions
-        updated_positions = self.armadillo.points() + 0.1 * random(self.armadillo.points().shape)
+        updated_positions = self.mesh.vertices + 0.1 * random(self.mesh.vertices.shape)
         self.factory.update_mesh(object_id=0,
                                  positions=updated_positions)
         self.factory.render()
@@ -43,7 +44,8 @@ def close(self):
 if __name__ == '__main__':
 
     # 1. Create a new Database
-    db = Database(database_name='several_factories_offscreen').new(remove_existing=True)
+    db = Database(database_dir='my_databases',
+                  database_name='several_factories_offscreen').new(remove_existing=True)
 
     # 2. Create several simulations
     nb_simu = 2
@@ -63,5 +65,6 @@ def close(self):
     # 5. Close the Factories & Replay steps
     for simu in simulations:
         simu.close()
-    Replay(database_name='several_factories_offscreen',
+    Replay(database_dir='my_databases',
+           database_name='several_factories_offscreen',
            backend='vedo' if len(argv) == 1 else argv[1]).launch()

examples/Core/rendering/visualization.py

@@ -3,40 +3,41 @@
 from numpy.random import random
 from sys import argv
 
-from SSD.Core import UserAPI
+from SSD.Core.Rendering import UserAPI
 
 # 1. Create the visualization API
-factory = UserAPI(database_name='visualization',
+factory = UserAPI(database_dir='my_databases',
+                  database_name='visualization',
                   remove_existing=True)
 
 # 2. Create the object to render
-armadillo = Mesh('armadillo.obj')
+mesh = Mesh('armadillo.obj').compute_normals()
 
 # 3. Add objects to the Visualizer
 # 3.1. Add a Mesh (object_id = 0)
-factory.add_mesh(positions=armadillo.points(),
-                 cells=armadillo.cells(),
+factory.add_mesh(positions=mesh.vertices,
+                 cells=mesh.cells,
                  at=0,
                  alpha=0.8,
                  c='orange6',
                  wireframe=False,
                  line_width=0.)
 # 3.2. Add a PointCloud (object_id = 1)
-factory.add_points(positions=armadillo.points(),
+factory.add_points(positions=mesh.vertices,
                    at=1,
                    point_size=5,
-                   scalar_field=armadillo.points()[:, 1])
+                   scalar_field=mesh.vertices[:, 1])
 # 3.3. Add Arrows (object_id = 2)
-factory.add_arrows(positions=armadillo.points()[:100],
-                   vectors=armadillo.normals()[:100],
+factory.add_arrows(positions=mesh.vertices[:100],
+                   vectors=mesh.vertex_normals[:100],
                    at=2,
                    res=15)
 # 3.4. Add Markers (object_id = 3)
 factory.add_markers(normal_to=0,
                     indices=arange(0, 10),
                     at=3,
                     size=1,
-                    symbol='0')
+                    symbol='*')
 # 3.5. Add Text (object_id = 4)
 factory.add_text(content='0',
                  at=0,
@@ -47,29 +48,30 @@
 factory.launch_visualizer(backend='vedo' if len(argv) == 1 else argv[1],
                           fps=20)
 
-# 5. Run a few steps
+# # 5. Run a few steps
 for step in range(100):
-    updated_armadillo = armadillo.clone().points(armadillo.points() + 0.1 * random(armadillo.points().shape))
+    updated_mesh = mesh.clone()
+    updated_mesh.vertices = mesh.vertices + 0.1 * random(mesh.vertices.shape)
     # 5.1. Update the Mesh
     factory.update_mesh(object_id=0,
-                        positions=updated_armadillo.points())
+                        positions=updated_mesh.vertices)
     if step == 50:
         factory.update_mesh(object_id=0,
                             wireframe=True,
                             alpha=1.,
                             line_width=2.)
     # 5.2. Update the PointCloud
     factory.update_points(object_id=1,
-                          positions=updated_armadillo.points())
+                          positions=updated_mesh.vertices)
     if step == 50:
         factory.update_points(object_id=1,
                               alpha=0.5,
                               point_size=10,
-                              scalar_field=armadillo.points()[:, 2])
+                              scalar_field=mesh.vertices[:, 2])
     # 5.3. Update the Arrows
     factory.update_arrows(object_id=2,
-                          positions=armadillo.points()[step:step + 100],
-                          vectors=armadillo.normals()[step:step + 100])
+                          positions=mesh.vertices[step:step + 100],
+                          vectors=mesh.vertex_normals[step:step + 100])
     if step == 50:
         factory.update_arrows(object_id=2,
                               c='red')

src/Core/Rendering/__init__.py

@@ -1,3 +1,3 @@
-from .Replay import Replay
-from .Visualizer import Visualizer
-from .UserAPI import UserAPI
+from .replay import Replay
+from .visualizer import Visualizer
+from .user_api import UserAPI