Start work on visual and collision

Author: bakpaul

stlib/entities/deformable/__deformable__.py

@@ -1,14 +1,34 @@
 from stlib.entities import Entity
 from stlib.entities.deformable.__parameters__ import  DeformableParameters
-
+from stlib.geometry import Geometry
+from stlib.prefabs.visual import Visual
+from stlib.prefabs.collision import Collision
 
 class Deformable(Entity):
-   
+    params : DeformableParameters
+
     @staticmethod
     def getParameters(**kwargs) -> DeformableParameters:
         return DeformableParameters(**kwargs)
 
 
     def __init__(self, params : DeformableParameters, **kwargs):
-        Entity.__init__(self, **kwargs)    
+        Entity.__init__(self, **kwargs)   
+        self.add(Geometry, params.geometry)
+        self.__addConstitutiveLaw__()
+        self.add(Collision, params.collision)
+
+    #@customizable
+    # Need generic way of defining paramaters (linear/hyper...)
+    def __addConstitutiveLaw__(self):
+        self.params.addConstitutiveLaw()
+
+    
+    
+    #@customizable
+    def __addVisual__(self):
+        #Exctract surface and add indentity mapping
+
+        self.add(Visual, params.visual)
 
+        pass

stlib/entities/deformable/__parameters__.py

@@ -1,10 +1,18 @@
 from stlib.core.baseParameters import BaseParameters, Callable, Optional, dataclasses
+from stlib.geometry import GeometryParameters
+from stlib.prefabs.visual import VisualParameters
+from stlib.prefabs.collision import CollisionParameters
 
 @dataclasses.dataclass
 class DeformableParameters(BaseParameters):     
-    addConstitutiveLaw : Callable = lambda x: x
 
-    mass : Optional[float] = None    
+    geometry : GeometryParameters
+    # Add default value
+    visual  : VisualParameters 
+    collision  : CollisionParameters
+    mass : float = float  
+
+    addConstitutiveLaw : Callable = lambda x: x
 
     def toDict(self):
         return dataclasses.asdict(self)

stlib/entities/rigid/__parameters__.py

@@ -1,8 +1,10 @@
 from stlib.core.baseParameters import BaseParameters, Callable, Optional, dataclasses
+from stlib.geometry import GeometryParameters
 
 @dataclasses.dataclass
 class RigidParameters(BaseParameters):     
 
+    geometry : GeometryParameters
     mass : Optional[float] = None    
 
     def toDict(self):

stlib/geometry/file.py

@@ -11,6 +11,7 @@ def __init__(self,  filename, dynamicTopology = False):
     @staticmethod
     def createData(filename) -> GeometryParameters.Data :
         data = GeometryParameters.Data()
+        
         node = Sofa.Core.Node()
         loadMesh(node, filename)
         node.init()

stlib/prefabs/collision.py

@@ -0,0 +1,18 @@
+from stlib.core.basePrefab import BasePrefab
+from stlib.core.baseParameters import BaseParameters, Callable, Optional, dataclasses, Any
+from stlib.geometry import GeometryParameters
+from Sofa.Core import Object 
+
+@dataclasses.dataclass
+class CollisionParameters(BaseParameters):
+    primitives : list[Any] #TODO: add enum type in splib
+
+    geometry : GeometryParameters
+    addMapping : Callable
+
+
+class Collision(BasePrefab):
+
+    def __init__(self, params: GeometryParameters):
+        BasePrefab.__init__(self, params)
+

stlib/prefabs/visual.py

@@ -1,32 +1,21 @@
-from stlib.core.parameters import EntityParameters 
-import dataclasses
-import Sofa
+from stlib.core.basePrefab import BasePrefab
+from stlib.core.baseParameters import BaseParameters, Callable, Optional, dataclasses, Any
+from stlib.geometry import GeometryParameters
+from Sofa.Core import Object 
 
-class VisualModel(Sofa.Core.BasePrefab):
-    @dataclasses.dataclass
-    class Parameters(EntityParameters):
-        name : str = "VisualModel"
+@dataclasses.dataclass
+class VisualParameters(BaseParameters):
+    color : Optional[list[float]]
+    texture :  Optional[str]
 
-        filename : str = "mesh/sphere_02.obj"
-        
-        renderer : dict = dataclasses.field(default_factory=dict)
-        mapping : dict = dataclasses.field(default_factory=dict)
+    geometry : GeometryParameters
+    addMapping : Optional[Callable]
 
 
+class Visual(BasePrefab):
+    container :  Object # This should be more specialized into the right SOFA type
+    modifier : Optional[Object]
 
-    def __init__(self, parent=None, parameters : VisualModelParameters = VisualModelParameters()):
-        Sofa.Core.Node.__init__(self, name=parameters.name)
+    def __init__(self, params: GeometryParameters):
+        BasePrefab.__init__(self, params)
 
-        if parent != None:
-            parent.addChild(self)
-
-        self.addObject("MeshOBJLoader", name="loader", filename=parameters.filename)
-        self.addRenderer(**to_dict(parameters.renderer) | {"src" : "@loader"} )
-        self.addMapping(**to_dict(parameters.mapping) )
-
-    def addRenderer(self, **kwargs):
-        self.addObject("OglModel", name="renderer", **kwargs)
-
-    def addMapping(self, **kwargs):
-        self.addObject("RigidMapping", name="mapping", **kwargs)
-