Squashed commit of the following:

commit b0cffe7
Author: bakpaul <paul.baksic@outlook.fr>
Date:   Tue Mar 3 10:17:06 2026 +0100

    Dump ideas

commit 4baade5
Author: Damien Marchal <damien.marchal@univ-lille1.fr>
Date:   Thu Oct 30 16:06:25 2025 +0100

    Register in the PythonFactory Rigid3::Coord (#544)

    Because currently only Rigid3::VecCoord was supported.

commit dd6865e
Author: bakpaul <paul.baksic@outlook.fr>
Date:   Mon Mar 2 14:26:25 2026 +0100

    Make exctracted topo working'

commit de007a3
Author: Paul Baksic <paul.baksic@outlook.fr>
Date:   Wed Oct 29 17:31:41 2025 +0100

    Added S, but still need to make the free motion not crash

commit d3148a5
Author: Paul Baksic <paul.baksic@outlook.fr>
Date:   Wed Oct 29 12:21:41 2025 +0100

    Fix plane and some splib deprecated components

commit d2c120e
Author: Paul Baksic <paul.baksic@outlook.fr>
Date:   Tue Oct 28 18:22:41 2025 +0100

    Add plane, still need to really implement function + started creating the scene

Author: bakpaul

CMakeLists.txt

@@ -203,6 +203,12 @@ SP3_add_python_package(
     TARGET_DIRECTORY
         splib
 )
+SP3_add_python_package(
+    SOURCE_DIRECTORY
+        ${CMAKE_CURRENT_SOURCE_DIR}/stlib
+    TARGET_DIRECTORY
+        stlib
+)
 
 sofa_create_package(
     PACKAGE_NAME ${PROJECT_NAME}

examples/stlib/SofaScene.py

@@ -0,0 +1,121 @@
+from fontTools.afmLib import preferredAttributeOrder
+
+from stlib.geometries.plane import PlaneParameters
+from stlib.geometries.file import FileParameters
+from stlib.geometries.extract import ExtractParameters
+from stlib.materials.deformable import DeformableBehaviorParameters
+from stlib.collision import Collision, CollisionParameters
+from stlib.entities import Entity, EntityParameters
+from stlib.visual import Visual, VisualParameters
+from splib.core.enum_types import CollisionPrimitive, ElementType, ConstitutiveLaw
+from splib.simulation.headers import setupLagrangianCollision, setupDefaultHeader
+from splib.simulation.ode_solvers import addImplicitODE
+from splib.simulation.linear_solvers import addLinearSolver
+import dataclasses
+import numpy as np
+
+
+def createScene(root):
+    root.gravity=[0,0,9.81]
+    ##Solvers
+    # setupDefaultHeader(root, displayFlags = "showVisualModels",backgroundColor=[0.8, 0.8, 0.8, 1],
+    #                          parallelComputing = True)
+    setupLagrangianCollision(root, displayFlags = "showVisualModels",backgroundColor=[0.8, 0.8, 0.8, 1],
+                                 parallelComputing = True,alarmDistance=0.3, contactDistance=0.02,
+                                 frictionCoef=0.5, tolerance=1.0e-4, maxIterations=20)
+    ##Environement
+    planes_lengthNormal = np.array([0, 1, 0])
+    planes_lengthNbEdge = 1
+    planes_widthNbEdge = 2
+    planes_lengthSize = 30
+    planes_widthSize = 70
+
+    plane1_collisionParams = CollisionParameters()
+    plane1_collisionParams.name = "UP"
+    plane1_collisionParams.primitives = [CollisionPrimitive.TRIANGLES]
+    plane1_collisionParams.kwargs = {"TriangleCollision" : {"moving" : False, "simulated" : False}}
+    plane1_collisionParams.geometry = PlaneParameters(np.array([15,0,1]), np.array([0,0,-1]),
+                                                      planes_lengthNormal, planes_lengthNbEdge, planes_widthNbEdge, planes_lengthSize, planes_widthSize)
+    plane1 = root.add(Collision, parameters = plane1_collisionParams)
+    # TODO being able to reuse already loaded geometry of current prefab to add any new sub prefab
+    # We need to enable to directly pass a link to an already existing prefab in place of a prefab parameter object
+    plane1_visu = plane1.addChild("Visu")
+    plane1_visu.addObject("OglModel", name="VisualModel", src="@../Geometry/container")
+
+
+    plane2_collisionParams = CollisionParameters()
+    plane2_collisionParams.name = "DOWN"
+    plane2_collisionParams.primitives = [CollisionPrimitive.TRIANGLES]
+    plane2_collisionParams.kwargs = {"TriangleCollision" : {"moving" : False, "simulated" : False}}
+    plane2_collisionParams.geometry = PlaneParameters(np.array([15,0,-20]), np.array([0,0,1]),
+                                                      planes_lengthNormal, planes_lengthNbEdge, planes_widthNbEdge, planes_lengthSize, planes_widthSize)
+    plane2 = root.add(Collision, parameters = plane2_collisionParams)
+    plane2_visu = plane2.addChild("Visu")
+    plane2_visu.addObject("OglModel", name="VisualModel", src="@../Geometry/container")
+
+
+    ## Real models
+    # VolumetricObjects = root.addChild("VolumetricObjects")
+    # addImplicitODE(VolumetricObjects)
+    # addLinearSolver(VolumetricObjects, constantSparsity=False, )
+
+    ### Logo
+    LogoNode = root.addChild("LogoNode")
+    addImplicitODE(LogoNode)
+    addLinearSolver(LogoNode, constantSparsity=False, )
+
+    LogoParams = EntityParameters(name = "Logo",
+                                  geometry = FileParameters(filename="mesh/SofaScene/Logo.vtk"),
+                                  material = DeformableBehaviorParameters(),
+                                  collision = CollisionParameters(geometry = FileParameters(filename="mesh/SofaScene/LogoColli.sph")),
+                                  visual = VisualParameters(geometry = FileParameters(filename="mesh/SofaScene/LogoVisu.obj")))
+
+    LogoParams.geometry.elementType = ElementType.TETRAHEDRA
+    LogoParams.material.constitutiveLawType = ConstitutiveLaw.ELASTIC
+    LogoParams.material.parameters = [200, 0.4]
+    LogoParams.material.massDensity = 0.003261
+    LogoParams.collision.primitives = [CollisionPrimitive.SPHERES]
+    #TODO make this flawless with spheres. Here collisions elements are not in the topology and a link is to be made between the loader and the collision object
+    LogoParams.collision.kwargs = {"SphereCollision" : {"radius" : "@Geometry/loader.listRadius"}}
+    LogoParams.visual.color = [0.7, .35, 0, 0.8]
+
+    Logo = LogoNode.add(Entity, parameters = LogoParams)
+
+    Logo.material.addObject("ConstantForceField", name="ConstantForceUpwards", totalForce=[0, 0, -5.0])
+    Logo.material.addObject("LinearSolverConstraintCorrection", name="ConstraintCorrection", linearSolver=LogoNode.LinearSolver.linkpath, ODESolver=LogoNode.ODESolver.linkpath)
+
+
+    ### S
+    SNode = root.addChild("SNode")
+    addImplicitODE(SNode)
+    addLinearSolver(SNode, constantSparsity=False, )
+
+    SParams = EntityParameters("bob.yaml")
+    SParams.name = "S"
+    SParams.geometry = FileParameters(filename="mesh/SofaScene/S.vtk")
+    SParams.geometry.elementType = ElementType.TETRAHEDRA
+    SParams.material = DeformableBehaviorParameters()
+    SParams.material.constitutiveLawType = ConstitutiveLaw.ELASTIC
+    SParams.material.parameters = [200, 0.45]
+
+    def SAddMaterial(node):
+        DeformableBehaviorParameters.addDeformableMaterial(node)
+        #TODO deal with that is a more smooth way in the material directly
+        node.addObject("LinearSolverConstraintCorrection", name="ConstraintCorrection", linearSolver=SNode.LinearSolver.linkpath, ODESolver=SNode.ODESolver.linkpath)
+
+    SParams.material.addMaterial = SAddMaterial
+    SParams.material.massDensity = 0.011021
+    SParams.collision = CollisionParameters()
+    SParams.collision.primitives = [CollisionPrimitive.TRIANGLES]
+    # # #TODO: to fix link issues for extracted geometry, it might be better to give source geometry relative link + parameters
+    SParams.collision.geometry = ExtractParameters(destinationType=ElementType.TRIANGLES, sourceParameters=SParams.geometry )
+    SParams.visual = VisualParameters()
+    SParams.visual.geometry = FileParameters(filename="mesh/SofaScene/SVisu.obj")
+    SParams.visual.color = [0.7, .7, 0.7, 0.8]
+
+    S = SNode.add(Entity, parameters = SParams)
+
+
+    SDensity = 0.011021
+    ODensity = SDensity
+    ADensity = 0.00693695

splib/core/node_wrapper.py

@@ -25,7 +25,9 @@ def addObject(self,*args, **kwargs):
             parameters["name"] = kwargs["name"]
             if kwargs["name"] in kwargs:
                 if isinstance(kwargs[kwargs["name"]], dict):
-                    parameters = {**parameters, **kwargs[kwargs["name"]]}
+                    for param in kwargs[kwargs["name"]]:
+                        if not(isinstance(kwargs[kwargs["name"]][param],defaultValueType)):
+                            parameters = {**parameters, param : kwargs[kwargs["name"]][param]}
                 else:
                     print("[Warning] You are passing a keyword arg with the same name as one obj without it being a Dict, it will not be used. ")
 

splib/mechanics/collision_model.py

@@ -24,7 +24,7 @@ def addCollisionModels(node, primitive : CollisionPrimitive,
             node.addObject("TriangleCollisionModel", name="TriangleCollision", topology=topology, selfCollision=selfCollision, proximity=proximity, contactStiffness=contactStiffness, contactFriction=contactFriction, group=group,**kwargs)
             return
         case CollisionPrimitive.SPHERES:
-            node.addObject("SphereCollisionModel", name="SphereCollision", topology=topology, selfCollision=selfCollision, proximity=proximity, contactStiffness=contactStiffness, contactFriction=contactFriction, group=group, radius=spheresRadius, **kwargs)
+            node.addObject("SphereCollisionModel", name="SphereCollision", selfCollision=selfCollision, proximity=proximity, contactStiffness=contactStiffness, contactFriction=contactFriction, group=group, radius=spheresRadius, **kwargs)
             return
         case _:
             return

stlib/collision.py

@@ -27,7 +27,7 @@ def __init__(self, parameters: CollisionParameters):
 
     def init(self):
 
-        geom = self.add(Geometry, self.parameters.geometry)
+        geom = self.add(Geometry, parameters = self.parameters.geometry)
 
         self.addObject("MechanicalObject", template="Vec3", position=f"@{self.parameters.geometry.name}/container.position")
         for primitive in self.parameters.primitives:

stlib/entities/__entity__.py

@@ -65,16 +65,17 @@ def init(self):
     def addMapping(self, destinationPrefab):
 
         template = f'{self.parameters.stateType},Vec3' # TODO: check that it is always true
-        
+
+        #TODO: all paths are expecting Geometry to be called Geomtry and so on. We need to robustify this by using the name parameter somehow
         if( self.parameters.stateType == StateType.VEC3):
             destinationPrefab.addObject("BarycentricMapping", 
                                         output=destinationPrefab.linkpath, 
-                                        output_topology=destinationPrefab.geometry.container.linkpath,
-                                        input=self.material.linkpath, 
-                                        input_topology=self.geometry.container.linkpath, 
+                                        output_topology=destinationPrefab.Geometry.container.linkpath,
+                                        input=self.Material.linkpath,
+                                        input_topology=self.Geometry.container.linkpath,
                                         template=template)
         else:
             destinationPrefab.addObject("RigidMapping", 
                                          output=destinationPrefab.linkpath, 
-                                        input=self.material.linkpath, 
+                                        input=self.Material.linkpath,
                                         template=template)

stlib/geometries/__geometry__.py

@@ -4,7 +4,9 @@
 from splib.topology.static import addStaticTopology
 from splib.core.enum_types import ElementType
 from splib.core.utils import DEFAULT_VALUE
-from Sofa.Core import Object 
+from Sofa.Core import Object
+
+import numpy as np
 
 
 class Geometry(BasePrefab):...
@@ -33,6 +35,10 @@ class GeometryParameters(BaseParameters):
 
     dynamicTopology : bool = False
 
+    def Data(self):
+        return InternalDataProvider()
+
+
 
 class Geometry(BasePrefab):
     # container : Object # This should be more specialized into the right SOFA type
@@ -48,11 +54,19 @@ def __init__(self, parameters: GeometryParameters):
     def init(self):
 
         # Generate attribute (positions, edges, triangles, quads, tetrahedra, hexahedra) from the internal data provider
-        if self.parameters.data is not None :
+        if isinstance(self.parameters.data, InternalDataProvider) :
             self.parameters.data.generateAttribute(self)
+
         if self.parameters.dynamicTopology :
             if self.parameters.elementType is not None :
-                addDynamicTopology(self, container = dataclasses.asdict(self.parameters.data))
+                addDynamicTopology(self, elementType=self.parameters.elementType, container = {
+                                                                                                "position": self.parameters.data.position,
+                                                                                                "edges": self.parameters.data.edges,
+                                                                                                "triangles": self.parameters.data.triangles,
+                                                                                                "quads": self.parameters.data.quads,
+                                                                                                "tetrahedra": self.parameters.data.tetrahedra,
+                                                                                                "hexahedra": self.parameters.data.hexahedra
+                                                                                            })
             else:
                 raise ValueError
         else:

stlib/geometries/extract.py

@@ -25,7 +25,7 @@ def __post_init__(self):
 
         InternalDataProvider.__init__(self)
 
-    def generateAttribute(self, parent : Geometry):                
+    def generateAttribute(self, parent : Geometry):
         node = parent.addChild("ExtractedGeometry")
 
         #TODO: Specify somewhere in the doc that this should only be used for mapped topologies that extract parent topology surface
@@ -34,8 +34,8 @@ def generateAttribute(self, parent : Geometry):
         # !!! also, on a fail, nothing is added to the graph, which makes things harder to debug
         # !!! also, does not work because of the function canCreate(), which checks the input (not yet created?)
         # this is all related
-        fromLink = "@../../Geometry.container" # TODO: can we do better than this?
-        addDynamicTopology(node, elementType=self.sourceType)
+        fromLink = "@../../../Geometry/container" # TODO: can we do better than this?
+        addDynamicTopology(node, elementType=self.destinationType, container={"position" : fromLink + ".position"})
         if self.sourceType == ElementType.TETRAHEDRA:
             node.addObject("Tetra2TriangleTopologicalMapping", input=fromLink, output=node.container.linkpath)
         elif self.sourceType == ElementType.HEXAHEDRA:
@@ -60,12 +60,11 @@ def generateAttribute(self, parent : Geometry):
 class ExtractParameters(GeometryParameters):
     def __init__(self, 
                  sourceParameters : GeometryParameters, 
-                 destinationType : ElementType,  
-                 dynamicTopology : bool = False, ):
+                 destinationType : ElementType,):
         GeometryParameters.__init__(self,
                                     data = ExtractInternalDataProvider(destinationType = destinationType, 
                                                                        sourceType = sourceParameters.elementType,
                                                                        sourceName = sourceParameters.name), 
-                                    dynamicTopology = dynamicTopology, 
+                                    dynamicTopology = True,
                                     elementType = destinationType)
 

stlib/geometries/file.py

@@ -13,14 +13,20 @@ def __post_init__(self, **kwargs):
         InternalDataProvider.__init__(self,**kwargs)
 
     def generateAttribute(self, parent : Geometry):    
-        loadMesh(parent, self.filename)      
-
-        self.position = str(parent.loader.position.linkpath)
-        self.edges = str(parent.loader.edges.linkpath)
-        self.triangles = str(parent.loader.triangles.linkpath)
-        self.quads = str(parent.loader.quads.linkpath)
-        self.hexahedra = str(parent.loader.hexahedra.linkpath)
-        self.tetrahedra = str(parent.loader.tetras.linkpath)
+        loadMesh(parent, self.filename)
+
+        if hasattr(parent.loader, 'position'):
+            self.position = str(parent.loader.position.linkpath)
+        if hasattr(parent.loader, 'edges'):
+            self.edges = str(parent.loader.edges.linkpath)
+        if hasattr(parent.loader, 'triangles'):
+            self.triangles = str(parent.loader.triangles.linkpath)
+        if hasattr(parent.loader, 'quads'):
+            self.quads = str(parent.loader.quads.linkpath)
+        if hasattr(parent.loader, 'hexahedra'):
+            self.hexahedra = str(parent.loader.hexahedra.linkpath)
+        if hasattr(parent.loader, 'tetrahedra'):
+            self.tetrahedra = str(parent.loader.tetrahedra.linkpath)
 
 
 

stlib/geometries/plane.py

@@ -0,0 +1,45 @@
+from stlib.geometries import GeometryParameters, InternalDataProvider, Geometry
+import dataclasses
+import numpy as np
+
+@dataclasses.dataclass
+class PlaneDataProvider(InternalDataProvider):
+    center : np.ndarray[float] = dataclasses.field(default_factory = lambda : np.array([0,0,0]))
+    normal : np.ndarray[float] = dataclasses.field(default_factory = lambda : np.array([0,0,1]))
+    lengthNormal : np.ndarray[float] = dataclasses.field(default_factory = lambda : np.array([1,0,0]))
+    lengthNbEdge : int = 1
+    widthNbEdge : int = 1
+    lengthSize : float = 1.0
+    widthSize : float = 1.0
+
+    def __post_init__(self, **kwargs):
+        InternalDataProvider.__init__(self,**kwargs)
+
+    def generateAttribute(self, parent : Geometry):
+
+        lengthEdgeSize = self.lengthSize / self.lengthNbEdge
+        widthEdgeSize = self.widthSize / self.widthNbEdge
+
+        self.widthNormal = np.cross(self.normal,self.lengthNormal)
+        bottomLeftCorner = self.center - self.lengthNormal * self.lengthNbEdge * lengthEdgeSize / 2 - self.widthNormal * self.widthNbEdge * widthEdgeSize / 2
+
+        self.position = np.array([[ bottomLeftCorner + j * self.widthNormal * widthEdgeSize + i * self.lengthNormal * lengthEdgeSize   for j in range(self.widthNbEdge + 1) ] for i in range(self.lengthNbEdge + 1)])
+
+        self.triangles = np.empty((2 * self.widthNbEdge * self.lengthNbEdge, 3), dtype = int)
+        for i in range(self.lengthNbEdge):
+            for j in range(self.widthNbEdge):
+                self.triangles[i*self.widthNbEdge*2 + j * 2    , 0] = j     + i     * (self.widthNbEdge + 1)
+                self.triangles[i*self.widthNbEdge*2 + j * 2    , 1] = j     + (i+1) * (self.widthNbEdge + 1)
+                self.triangles[i*self.widthNbEdge*2 + j * 2    , 2] = j + 1 + i     * (self.widthNbEdge + 1)
+                self.triangles[i*self.widthNbEdge*2 + j * 2 + 1, 0] = j + 1 + i     * (self.widthNbEdge + 1)
+                self.triangles[i*self.widthNbEdge*2 + j * 2 + 1, 1] = j     + (i+1) * (self.widthNbEdge + 1)
+                self.triangles[i*self.widthNbEdge*2 + j * 2 + 1, 2] = j + 1 + (i+1) * (self.widthNbEdge + 1)
+
+
+
+
+class PlaneParameters(GeometryParameters):
+
+    def __init__(self,  center, normal, lengthNormal, lengthNbEdge, widthNbEdge, lengthSize, widthSize, dynamicTopology = False):
+        GeometryParameters.__init__(self, data = PlaneDataProvider(center=center, normal=normal, lengthNormal=lengthNormal, lengthNbEdge=lengthNbEdge, widthNbEdge=widthNbEdge, lengthSize=lengthSize, widthSize=widthSize),
+                                    dynamicTopology = dynamicTopology)