Add extracted geometry

Author: bakpaul

stlib/geometry/__geometry__.py

@@ -3,38 +3,52 @@
 from splib.topology.dynamic import addDynamicTopology
 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 
 
+
+class Geometry(BasePrefab):...
+
 @dataclasses.dataclass
-class GeometryParameters(BaseParameters):
-    @dataclasses.dataclass
-    class Data(object):
-        # Initial positions
-        positions : Any
+class InternalDataProvider(object):
+    positions : Any
+    # Topology information
+    edges : Any = DEFAULT_VALUE
+    triangles : Any  = DEFAULT_VALUE
+    quads : Any  = DEFAULT_VALUE
+    tetrahedra : Any  = DEFAULT_VALUE
+    hexahedra : Any  = DEFAULT_VALUE
+
+    def generateAttribute(self, parent : Geometry):
+        pass
+
 
-        # Type of the highest degree element
-        elementType : Optional[ElementType]
+@dataclasses.dataclass
+class GeometryParameters(BaseParameters):
 
-        # Topology information
-        edges : Optional[Any]
-        triangles : Optional[Any]
-        quads : Optional[Any]
-        tetrahedra : Optional[Any]
-        hexahedra : Optional[Any]
+    # Type of the highest degree element
+    elementType : Optional[ElementType]
 
     dynamicTopology : bool = False
-    data : Data
+    data : Optional[InternalDataProvider]
+
+
 
 class Geometry(BasePrefab):
     container :  Object # This should be more specialized into the right SOFA type
     modifier : Optional[Object]
 
+    params : GeometryParameters
+
     def __init__(self, params: GeometryParameters):
         BasePrefab.__init__(self, params)
+        self.params = params 
+        if params.data is not None :
+            params.data.generateAttribute(self)
         if(params.dynamicTopology):
             if(params.elementType is not None):
-                addDynamicTopology(self, **dataclasses.asdict(params.data), **params.kargs)
+                addDynamicTopology(self, container = {dataclasses.asdict(params.data)})
             else:
                 raise ValueError
         else:
-            addStaticTopology(self, **dataclasses.asdict(params.data), **params.kargs)
+            addStaticTopology(self, container = {dataclasses.asdict(params.data)})

stlib/geometry/extract.py

@@ -0,0 +1,46 @@
+from stlib.geometry import GeometryParameters, InternalDataProvider, Geometry
+from stlib.core.baseParameters import dataclasses
+from splib.topology.dynamic import addDynamicTopology
+from splib.topology.loader import loadMesh
+from splib.core.enum_types import ElementType
+
+from Sofa.Core import Node
+
+
+class ExtractInternalDataProvider(InternalDataProvider):
+    destElemType : ElementType
+    fromElemType : ElementType
+    fromNodeName : str
+
+    def __post_init__(self):
+        if(not (self.fromElemType == ElementType.TETRA and self.destElemType == ElementType.TRIANGLES)
+           and not (self.fromElemType == ElementType.HEXA and self.destElemType == ElementType.QUAD) ):
+            raise ValueError("Only configuration possible are 'Tetra to Triangle' and 'Hexa to quad'")
+
+        InternalDataProvider.__init__(self)
+
+
+    def generateAttribute(self, parent : Geometry):                
+        tmn = parent.addChild("topologicalMappingNode")
+
+        #TODO: Specify somewhere in the doc that this should only be used for mapped topologies that extract parent topology surface
+        fromLink = parent.parents[0].parents[0].getChild(self.fromNodeName).container.linkpath
+        addDynamicTopology(tmn, type=self.destElemType)
+        if self.fromElemType == ElementType.TETRA:
+            tmn.addObject("Tetra2TriangleTopologicalMapping", input=fromLink, output=tmn.container.linkpath)
+        elif self.fromElemType == ElementType.HEXA:
+            tmn.addObject("Hexa2QuadTopologicalMapping", input=fromLink, output=tmn.container.linkpath)
+
+        self.positions = tmn.container.position.linkpath
+        self.edges = tmn.container.edges.linkpath
+        self.triangles = tmn.container.triangles.linkpath
+        self.quads = tmn.container.quads.linkpath
+        self.hexaedra = tmn.container.hexaedra.linkpath
+        self.tetrahedra = tmn.container.tetras.linkpath
+
+
+
+class ExtractParameters(GeometryParameters):
+    def __init__(self, fromGeometry : GeometryParameters, destElementType : ElementType,  dynamicTopology = False, ):
+        GeometryParameters.__init__(data = ExtractInternalDataProvider(destElemType = destElementType, fromElemType = fromGeometry.elementType,fromNodeName = fromGeometry.name), dynamicTopology = dynamicTopology, elementType = destElementType)
+        

stlib/geometry/file.py

@@ -1,27 +1,31 @@
-from stlib.geometry import GeometryParameters
+from stlib.geometry import GeometryParameters, InternalDataProvider, Geometry
+from stlib.core.baseParameters import dataclasses
 from splib.topology.loader import loadMesh
+from splib.core.enum_types import ElementType
+
 from Sofa.Core import Node
 
-class FileParameters(GeometryParameters):
-    def __init__(self,  filename, dynamicTopology = False):
+@dataclasses.dataclass
+class FileInternalDataProvider(InternalDataProvider):
+    filename : str
 
-        customGeom = FileParameters.createData(filename)
-        GeometryParameters.__init__(data = customGeom, dynamicTopology = dynamicTopology)
+    def __post_init__(self, **kwargs):
+        InternalDataProvider.__init__(self,**kwargs)
 
-    @staticmethod
-    def createData(filename) -> GeometryParameters.Data :
-        data = GeometryParameters.Data()
-        
-        node = Sofa.Core.Node()
-        loadMesh(node, filename)
-        node.init()
+    def generateAttribute(self, parent : Geometry):        
+    
+        loadMesh(parent, self.filename)
 
-        data.positions = node.loader.position.value
-        data.edges = node.loader.edges.value
-        data.triangles = node.loader.triangles.value
-        data.tetrahedra = node.loader.tetras.value
+        self.positions = parent.loader.position.linkpath
+        self.edges = parent.loader.edges.linkpath
+        self.triangles = parent.loader.triangles.linkpath
+        self.quads = parent.loader.quads.linkpath
+        self.hexaedra = parent.loader.hexaedra.linkpath
+        self.tetrahedra = parent.loader.tetras.linkpath
 
-        node.cleanUp()
 
-        return data
-        
+
+class FileParameters(GeometryParameters):
+    def __init__(self,  filename, dynamicTopology = False, elementType : ElementType = None ):
+        GeometryParameters.__init__(data = FileInternalDataProvider(filename), dynamicTopology = dynamicTopology, elementType = elementType)
+