Add beginner example

bakpaul · bakpaul · commit a5cba09d0a81 · 2025-04-14T17:49:47.000+02:00
diff --git a/examples/stlib/PrefabScene_beginner.py b/examples/stlib/PrefabScene_beginner.py
@@ -1,8 +1,32 @@
+from stlib.entities.rigid import Rigid
 from stlib.entities.deformable import Deformable
+from stlib.geometry.cube import CubeParameters
+from stlib.geometry.file import FileParameters
+from splib.simulation.headers import setupLagrangianCollision
+from splib.simulation.linear_solvers import addLinearSolver
+from splib.simulation.ode_solvers import addImplicitODE
+
+#To be added in splib
+def addSolvers(root):
+    addLinearSolver(root)
+    addImplicitODE(root)
+    root.addObject("LinearSolverConstraintCorrection", linearsolver="@LinearSolver")
 
 def createScene(root):
-    params = Deformable.getParameters()
-    params.name = "Logo"
-    params.topology.filename="share/mesh/SOFA-logo.obj"
-    root.add(Deformable, params=params)     
+    root.gravity = [0, 0, -9.81]
+
+    setupLagrangianCollision(root)
+    addSolvers(root)
+
+    rigidParams = Rigid.getParameters()
+    rigidParams.geometry = CubeParameters([0, 0, 0], 1, 3)
+    root.add(Rigid,rigidParams)
+
+    
+    deformableParams = Deformable.getParameters()
+    #Add transformation somewhere here
+    deformableParams.geometry = FileParameters("SofaScene/Logo.vtk")
+    root.add(Deformable,deformableParams)
+
+
     return root
diff --git a/splib/topology/loader.py b/splib/topology/loader.py
@@ -9,11 +9,11 @@ def loadMesh(node,filename,**kwargs):
 
     if splitedName[-1] in ['vtk', 'obj', 'stl', 'msh', 'sph']:
         if splitedName[-1] == "msh":
-            return node.addObject("MeshGmshLoader", name="meshLoader",filename=filename, **kwargs)
+            return node.addObject("MeshGmshLoader", name="loader",filename=filename, **kwargs)
         elif splitedName[-1] == "sph":
-            return node.addObject("SphereLoader", name="meshLoader",filename=filename, **kwargs)
+            return node.addObject("SphereLoader", name="loader",filename=filename, **kwargs)
         else:
-            return node.addObject("Mesh"+splitedName[-1].upper()+"Loader", name="meshLoader",filename=filename, **kwargs)
+            return node.addObject("Mesh"+splitedName[-1].upper()+"Loader", name="loader",filename=filename, **kwargs)
     else:
         print('[Error] : File extension ' + splitedName[-1] + ' not recognised.')
 
diff --git a/stlib/__init__.py b/stlib/__init__.py
@@ -1 +1 @@
-__all__ = ["core","simulated"]
+__all__ = ["core","entities","prefabs","shapes"]
diff --git a/stlib/core/baseEntity.py b/stlib/core/baseEntity.py
@@ -1,5 +1,5 @@
 import Sofa.Core
-from base_parameters import BaseParameters
+from baseParameters import BaseParameters
 
 class BaseEntity(Sofa.Core.Prefab):
 
diff --git a/stlib/core/baseParameters.py b/stlib/core/baseParameters.py
@@ -6,7 +6,7 @@
 
 @dataclasses.dataclass
 class BaseParameters(object): 
-    name : str = "Entity"
+    name : str = "object"
     kwargs : dict = dataclasses.field(default_factory=dict)
 
     def toDict(self):
diff --git a/stlib/entities/__entity__.py b/stlib/entities/__entity__.py
@@ -1,23 +1,26 @@
 from stlib.core.baseParameters import BaseParameters
 import dataclasses
-from typing import Callable, Optional, overload
+from typing import Callable, Optional, overload, Any
+from stlib.geometry import GeometryParameters
 import Sofa
 
 @dataclasses.dataclass
 class EntityParameters(BaseParameters): 
-    name : str = "Entity"
+    name = "Entity"
+
+    # addSimulation : Callable = Simulation
+    # addCollisionModel : Callable = CollisionModel
+    # addVisualModel : Callable = VisualModel 
+
 
-    addSimulation : Callable = Simulation
-    addCollisionModel : Callable = CollisionModel
-    addVisualModel : Callable = VisualModel 
 
     #setConstitutiveLaw # : Callable = addBidule
     #setBoundaryCondition #: Callable = addBidule
-    
-    mechanical : dict = dataclasses.field(default_factory=dict)
-    collision : CollisionModel.Parameters = CollisionModel.Parameters()
-    visual : VisualModelParameters = VisualModelParameters()
-    simulation : SimulationParameters = SimulationParameters()
+    geometry : GeometryParameters
+    # mechanical : dict = dataclasses.field(default_factory=dict)
+    # collision : CollisionModel.Parameters = CollisionModel.Parameters()
+    # visual : VisualModelParameters = VisualModelParameters()
+    # simulation : SimulationParameters = SimulationParameters()
     
 
 
diff --git a/stlib/entities/__init__.py b/stlib/entities/__init__.py
@@ -0,0 +1 @@
+from __entity__ import *
diff --git a/stlib/entities/deformable/__deformable__.py b/stlib/entities/deformable/__deformable__.py
@@ -5,8 +5,8 @@
 class Deformable(Entity):
    
     @staticmethod
-    def getParameters() -> DeformableParameters:
-        return DeformableParameters()
+    def getParameters(**kwargs) -> DeformableParameters:
+        return DeformableParameters(**kwargs)
         
 
     def __init__(self, params : DeformableParameters, **kwargs):
diff --git a/stlib/entities/deformable/__init__.py b/stlib/entities/deformable/__init__.py
@@ -0,0 +1,2 @@
+from  __deformable__ import *
+from  __parameters__ import *
diff --git a/stlib/entities/deformable/__parameters__.py b/stlib/entities/deformable/__parameters__.py
@@ -1,12 +1,10 @@
-
-import dataclasses
-from stlib.core.base_parameters import BaseParameters
+from stlib.core.baseParameters import BaseParameters, Callable, Optional, dataclasses
 
 @dataclasses.dataclass
 class DeformableParameters(BaseParameters):     
     addConstitutiveLaw : Callable = lambda x: x
 
     mass : Optional[float] = None    
 
-    def to_dict(self):
+    def toDict(self):
         return dataclasses.asdict(self)
diff --git a/stlib/entities/rigid/__init__.py b/stlib/entities/rigid/__init__.py
@@ -0,0 +1 @@
+from __rigid__ import *
diff --git a/stlib/entities/rigid/__parameters__.py b/stlib/entities/rigid/__parameters__.py
@@ -0,0 +1,10 @@
+from stlib.core.baseParameters import BaseParameters, Callable, Optional, dataclasses
+
+@dataclasses.dataclass
+class DRigidParameters(BaseParameters):     
+    addConstitutiveLaw : Callable = lambda x: x
+
+    mass : Optional[float] = None    
+
+    def toDict(self):
+        return dataclasses.asdict(self)
diff --git a/stlib/entities/rigid/__rigid__.py b/stlib/entities/rigid/__rigid__.py
@@ -1,9 +1,15 @@
-from stlib.core.entity import Entity
-from stlib.core.parameters import EntityParameters
+from stlib.entities import Entity
+from stlib.entities.rigid.__parameters__ import  RigidParameters
 
 import dataclasses
 
 
 class Rigid(Entity):
+   
+    @staticmethod
+    def getParameters(**kwargs) -> RigidParameters:
+        return RigidParameters(**kwargs)
+        
+
     def __init__(self, **kwargs):
         Entity.__init__(self, **kwargs)    
diff --git a/stlib/entities/rigid/parameters.py b/stlib/entities/rigid/parameters.py
diff --git a/stlib/geometry/__geometry__.py b/stlib/geometry/__geometry__.py
@@ -1,76 +1,37 @@
 from stlib.core.basePrefab import BasePrefab
-from stlib.core.baseParameters import BaseParameters, Optional, dataclasses
-from splib.topology.loader import loadMesh
+from stlib.core.baseParameters import BaseParameters, Optional, dataclasses, Any
 from splib.topology.dynamic import addDynamicTopology
+from splib.topology.static import addStaticTopology
 from splib.core.enum_types import ElementType
 from Sofa.Core import Object 
 
-
-
 @dataclasses.dataclass
-class GeometryParameter(BaseParameters):
-    isDynamic : bool = False
-    elementType : Optional[ElementType]
-    positions : Optional[list]
-    edges : Optional[list]
-    triangles : Optional[list]
-    tetrahedra : Optional[list]
-    hexahedra : Optional[list]
-    quads : Optional[list]
-
+class GeometryParameters(BaseParameters):
+    @dataclasses.dataclass
+    class Data(object):
+        elementType : Optional[ElementType]
+        positions : Any
+        edges : Optional[Any]
+        triangles : Optional[Any]
+        tetrahedra : Optional[Any]
+        hexahedra : Optional[Any]
+        quads : Optional[Any]
+    dynamicTopology : bool = False
+    data : Data
 
 class Geometry(BasePrefab):
     container :  Object # This should be more specialized into the right SOFA type
     modifier : Optional[Object]
 
-    def __init__(self, params: GeometryParameter):
+    def __init__(self, params: GeometryParameters):
         BasePrefab.__init__(self, params)
-        if(param.isDynamic):
-            if(param.elementType is not None):
-                addDynamicTopology(self, param.elementType, **kargs)
+        if(params.dynamicTopology):
+            if(params.elementType is not None):
+                addDynamicTopology(self, **dataclasses.asdict(params.data), **params.kargs)
             else:
                 raise ValueError
+        else:
+            addStaticTopology(self, **dataclasses.asdict(params.data), **params.kargs)
 
 
-@dataclasses.dataclass
-class FileGeometryParameters(GeometryParameter):
-    filename : str
-
-
-class FileGeometry(Geometry):
-    loader : Object
-
-    def __init__(self,param : FileGeometryParameters):
-        loadMesh(self, param.filename, **param.kwargs)
-        param.positions = "@loader.positions"
-        param.edges = "@loader.edges"
-        param.positions = "@loader.positions"
-        param.positions = "@loader.positions"
-        Geometry.__init__(self,param)
-
-        pass
-
-
-
-def createScene(root):
-    from stlib.entities.deformable import Deformable 
-
-    fileParameters =  FileGeometryParameters(filename = "MyFile.obj",
-                                             isDynamic = True,
-                                             elementType=ElementType.TETRA,
-                                             name="geometry")
-
-
-
-    cubeGeometry = FileGeometry(FileGeometryParameters)
-
-    entityParam = Deformable.getParameters( geometry = cubeGeometry, name="MyCube")
-
-
-    myCube = root.addChild("MyCube")
-    cubeGeomtry = myCube.addChild("geometry")
 
-    cubeGeomtry.addObject("MeshObjLoader", name="loader", filenmae="MyFile.obj")
-    cubeGeomtry.addObject("TetrahedronSetTopologyContainer", name="container", positions="@loader.positions")
-    cubeGeomtry.addObject("TetrahedronSetTopologyModifier", name="modifier")
-    
diff --git a/stlib/geometry/__init__.py b/stlib/geometry/__init__.py
@@ -0,0 +1 @@
+from __geometry__ import *
diff --git a/stlib/geometry/cube.py b/stlib/geometry/cube.py
@@ -0,0 +1,14 @@
+from stlib.geometry import GeometryParameters
+
+class CubeParameters(GeometryParameters):
+    def __init__(self,  center, edgeLength, pointPerEdge, dynamicTopology = False):
+
+        customGeom = CubeParameters.createData(center, edgeLength, pointPerEdge)
+        GeometryParameters.__init__(data = customGeom, dynamicTopology = dynamicTopology)
+
+    @staticmethod
+    def createData(center, edgeLength, pointPerEdge) -> GeometryParameters.Data :
+        data = GeometryParameters.Data()
+        #Fill data
+        return data
+        
diff --git a/stlib/geometry/file.py b/stlib/geometry/file.py
@@ -0,0 +1,24 @@
+from stlib.geometry import GeometryParameters
+from splib.topology.loader import loadMesh
+from Sofa.Core import Node
+
+class FileParameters(GeometryParameters):
+    def __init__(self,  filename, dynamicTopology = False):
+
+        customGeom = FileParameters.createData(filename)
+        GeometryParameters.__init__(data = customGeom, dynamicTopology = dynamicTopology)
+
+    @staticmethod
+    def createData(filename) -> GeometryParameters.Data :
+        data = GeometryParameters.Data()
+        node = Sofa.Core.Node()
+        loadMesh(node, filename)
+        node.init()
+
+        data.positions = node.loader.position.value
+        data.edges = node.loader.edges.value
+        data.triangles = node.loader.triangles.value
+        data.tetrahedra = node.loader.tetras.value
+
+        return data
+        
diff --git a/stlib/geometry/sphere.py b/stlib/geometry/sphere.py
@@ -0,0 +1,14 @@
+from stlib.geometry import GeometryParameters
+
+class SphereParameters(GeometryParameters):
+    def __init__(self,  center, radius, pointPerRad, dynamicTopology = False):
+
+        customGeom = SphereParameters.createData(center, radius, pointPerRad)
+        GeometryParameters.__init__(data = customGeom, dynamicTopology = dynamicTopology)
+
+    @staticmethod
+    def createData(center, radius, pointPerRad) -> GeometryParameters.Data :
+        data = GeometryParameters.Data()
+        #Fill data
+        return data
+        

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		`-__all__ = ["core","simulated"]`
	`1`	`+__all__ = ["core","entities","prefabs","shapes"]`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+from __deformable__ import *`
	`2`	`+from __parameters__ import *`