SofaPython3

https://sofapython3.readthedocs.io/en/
Admin
SofaPython3 is a Python 3 binding for SOFA (Simulation Open Framework Architecture) that enables...
Tokens:1,107,758
Snippets:3,322
Trust Score:8.3
Update:10 months ago
Show doc for...
Tokens:
Raw
### Create and Get Path Name Example

Source: https://sofapython3.readthedocs.io/en/latest/content/modules/Sofa/generated/Sofa.Core/classes/Sofa.Core.Base

Demonstrates creating a Sofa node and adding an object, then retrieving the path name of the added object. This example illustrates object creation and path verification in Sofa.

```python
a = Sofa.Core.Node("root")
b = a.addObject("Camera", name="camera")
b.getPathName() # should returns "/root/camera"
```

--------------------------------

### Full SOFA Scene Initialization and GUI Setup in Python

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/_sources/content/UsingThePlugin.rst

This comprehensive Python script initializes a SOFA scene, sets up the root node with gravity and time step, and loads necessary SOFA modules. It also configures the collision pipeline and sets up the graphical user interface (GUI) for visualization and interaction. This serves as a complete example for creating and running a basic SOFA simulation.

```python
import Sofa
import Sofa.Gui


def main():
        # Call the SOFA function to create the root node
        root = Sofa.Core.Node("root")

        # Call the createScene function, as runSofa does
        createScene(root)

        # Once defined, initialization of the scene graph
        Sofa.Simulation.init(root)

        # Launch the GUI (qt or qglviewer)
        Sofa.Gui.GUIManager.Init("myscene", "qglviewer")
        Sofa.Gui.GUIManager.createGUI(root, __file__)
        Sofa.Gui.GUIManager.SetDimension(1080, 800)

        # Initialization of the scene will be done here
        Sofa.Gui.GUIManager.MainLoop(root)
        Sofa.Gui.GUIManager.closeGUI()


def createScene(rootNode):

            rootNode.addObject("VisualGrid", nbSubdiv=10, size=1000)

            # Define the root node properties
            rootNode.gravity=[0.0,-9.81,0.0]
            rootNode.dt=0.01

            # Loading all required SOFA modules
            confignode = rootNode.addChild("Config")
            confignode.addObject('RequiredPlugin', name="Sofa.Component.AnimationLoop", printLog=False)
            confignode.addObject('RequiredPlugin', name="Sofa.Component.Collision.Detection.Algorithm", printLog=False)
            confignode.addObject('RequiredPlugin', name="Sofa.Component.Collision.Detection.Intersection", printLog=False)
            confignode.addObject('RequiredPlugin', name="Sofa.Component.Collision.Geometry", printLog=False)
            confignode.addObject('RequiredPlugin', name="Sofa.Component.Collision.Response.Contact", printLog=False)
            confignode.addObject('RequiredPlugin', name="Sofa.Component.Constraint.Lagrangian.Correction", printLog=False)
            confignode.addObject('RequiredPlugin', name="Sofa.Component.Constraint.Lagrangian.Solver", printLog=False)
            confignode.addObject('RequiredPlugin', name="Sofa.Component.IO.Mesh", printLog=False)
            confignode.addObject('RequiredPlugin', name="Sofa.Component.LinearSolver.Iterative", printLog=False)
            confignode.addObject('RequiredPlugin', name="Sofa.Component.Mapping.NonLinear", printLog=False)
            confignode.addObject('RequiredPlugin', name="Sofa.Component.Mass", printLog=False)
            confignode.addObject('RequiredPlugin', name="Sofa.Component.ODESolver.Backward", printLog=False)
            confignode.addObject('RequiredPlugin', name="Sofa.Component.StateContainer", printLog=False)
            confignode.addObject('RequiredPlugin', name="Sofa.Component.Topology.Container.Constant", printLog=False)
            confignode.addObject('RequiredPlugin', name="Sofa.Component.Visual", printLog=False)
            confignode.addObject('RequiredPlugin', name="Sofa.GL.Component.Rendering3D", printLog=False)
            confignode.addObject('OglSceneFrame', style="Arrows", alignment="TopRight")


            # Collision pipeline
            rootNode.addObject('DefaultPipeline')
            rootNode.addObject('FreeMotionAnimationLoop')
            rootNode.addObject('GenericConstraintSolver', tolerance="1e-6", maxIterations="1000")
            rootNode.addObject('BruteForceBroadPhase')
```

--------------------------------

### Sofa Node and Context API Methods (Python)

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/content/modules/Sofa/generated/Sofa.Core/classes/Sofa.Core.Node

Provides Python examples for various API methods related to Sofa nodes and contexts. This includes getting node paths, root nodes, contexts, and template names, as well as checking object existence and initialization status.

```python
getPathName(_self : Sofa.Core.Node_) -> str
getRoot(_self : Sofa.Core.Node_) -> object
getRootContext(_self : Sofa.Core.BaseContext_) -> Sofa.Core.BaseContext
getRootPath(_self : Sofa.Core.Node_) -> str
getState(_self : Sofa.Core.BaseContext_) -> sofa::core::BaseState
getTemplateName(_self : Sofa.Core.Base_) -> str
getTime(_self : Sofa.Core.BaseContext_) -> float
getTopology(_self : Sofa.Core.BaseContext_) -> sofa::core::topology::Topology
hasObject(_self : Sofa.Core.Node_, _arg0 : str_) -> object
init(_self : Sofa.Core.Node_) -> None
isActive(_self : Sofa.Core.BaseContext_) -> bool
isInitialized(_self : Sofa.Core.Node_) -> bool
isSleeping(_self : Sofa.Core.BaseContext_) -> bool
```

--------------------------------

### Python: Sofa.Core.Link Example Usage

Source: https://sofapython3.readthedocs.io/en/latest/content/modules/Sofa/generated/Sofa.Core/classes/Sofa.Core.Link

Demonstrates how to create, find, and interact with Sofa.Core.Link objects in a Python script. This example assumes SofaRuntime and necessary plugins are imported and a basic SOFA node structure is set up.

```python
import Sofa.Core
import SofaRuntime

SofaRuntime.importPlugin("SofaComponentAll")

root = Sofa.Core.Node("root")
root.addObject("MechanicalObject", name="t")

# Assuming a link to 't' exists or can be created
# For demonstration, let's assume a link named 'mechanicalState'
# In a real scenario, this link would be established between components.
# link = root.findLink("mechanicalState") # This line would work if the link was predefined

# Placeholder for demonstration if 'findLink' doesn't directly work without prior setup
# If you have a Data object, you can create a link to it.
# For example, if 't' had a 'position' Data field:
# from Sofa.Core import Data
# my_data = root.getObject("MechanicalObject").position
# link = Sofa.Core.Link(my_data) # Simplified, actual link creation might be more complex

# Example usage of link methods (assuming 'link' is a valid Sofa.Core.Link object):
# print(link.getValueString()) # will print the value string of the linked data
# print(link.getHelp())      # will print the help message for the linked data
```

--------------------------------

### Install OpenGL Library on Ubuntu

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/_sources/content/UsingThePlugin.rst

Command to install the OpenGL library on Ubuntu, which may be required for launching runSofa.

```bash
sudo apt install libopengl0
```

--------------------------------

### Cloning, Configuring, Building, and Installing SofaPython3

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/_sources/content/Compilation.rst

This sequence of commands clones the SofaPython3 repository, configures the build using CMake with specific paths and build type, builds the plugin, and then installs it. This is part of the out-of-tree build process.

```bash
git clone https://github.com/sofa-framework/SofaPython3.git $SP3_SRC
cmake -DCMAKE_PREFIX_PATH=$SOFA_ROOT/lib/cmake \
        -DCMAKE_BUILD_TYPE=Release \
        -DCMAKE_INSTALL_PREFIX=$SP3_ROOT \
        -S $SP3_SRC \
        -B $SP3_BUILD
cmake --build $SP3_BUILD
cmake --install $SP3_BUILD
```

--------------------------------

### Install Python and Libraries (Ubuntu)

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/_sources/content/Installation.rst

Installs Python 3.8, pip, and necessary libraries like NumPy on Ubuntu systems. It also provides a command to install OpenGL for runSofa.

```bash
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt install libpython3.8 python3.8 python3-pip
python3.8 -m pip install numpy

sudo apt install libopengl0
```

--------------------------------

### Out-of-tree Build: Cloning, Configuring, and Building SofaPython3

Source: https://sofapython3.readthedocs.io/en/latest/content/Compilation

This sequence of commands clones the SofaPython3 repository, configures the build using CMake with specified paths and types, builds the project, and installs it. It requires SOFA to be installed and its path set in SOFA_ROOT.

```bash
$ git clone https://github.com/sofa-framework/SofaPython3.git $SP3_SRC
$ cmake -DCMAKE_PREFIX_PATH=$SOFA_ROOT/lib/cmake \
        -DCMAKE_BUILD_TYPE=Release \
        -DCMAKE_INSTALL_PREFIX=$SP3_ROOT \
        -S $SP3_SRC \
        -B $SP3_BUILD
$ cmake --build $SP3_BUILD
$ cmake --install $SP3_BUILD

```

--------------------------------

### Camera Class Methods: Initialization and View Setup in Python

Source: https://sofapython3.readthedocs.io/en/latest/content/modules/Sofa/generated/Sofa.Core/classes/Sofa.Core.MassRigid3d

This snippet covers initialization and view setup methods for the Camera class in Python. It includes functions for creating orthographic and perspective projections, adding data and links, and managing camera initialization and cleanup.

```python
class Camera:
    def Orthographic(self):
        # ... implementation ...
        pass

    def Perspective(self):
        # ... implementation ...
        pass

    def addData(self, data):
        # ... implementation ...
        pass

    def addLink(self, link):
        # ... implementation ...
        pass

    def addSlave(self, slave):
        # ... implementation ...
        pass

    def bwdInit(self):
        # ... implementation ...
        pass

    def cleanup(self):
        # ... implementation ...
        pass

    def clearLoggedMessages(self):
        # ... implementation ...
        pass

    def computeBBox(self):
        # ... implementation ...
        pass

    def countLoggedMessages(self):
        # ... implementation ...
        pass

    def findData(self, name):
        # ... implementation ...
        pass

    def findLink(self, name):
        # ... implementation ...
        pass

    def getAsACreateObjectParameter(self):
        # ... implementation ...
        pass

    def getCategories(self):
        # ... implementation ...
        pass

    def getClass(self):
        # ... implementation ...
        pass

    def getClassName(self):
        # ... implementation ...
        pass

    def getContext(self):
        # ... implementation ...
        pass

    def getData(self, name):
        # ... implementation ...
        pass

    def getDataFields(self):
        # ... implementation ...
        pass

    def getDefinitionSourceFileName(self):
        # ... implementation ...
        pass

    def getDefinitionSourceFilePos(self):
        # ... implementation ...
        pass

    def getInstanciationFileName(self):
        # ... implementation ...
        pass

    def getInstanciationSourceFilePos(self):
        # ... implementation ...
        pass

    def getLinkPath(self):
        # ... implementation ...
        pass

    def getLinks(self):
        # ... implementation ...
        pass

    def getLoggedMessagesAsString(self):
        # ... implementation ...
        pass

    def getLookAtFromOrientation(self):
        # ... implementation ...
        pass

    def getMaster(self):
        # ... implementation ...
        pass

    def getModelViewMatrix(self):
        # ... implementation ...
        pass

    def getName(self):
        # ... implementation ...
        pass

    def getOpenGLModelViewMatrix(self):
        # ... implementation ...
        pass

    def getOpenGLProjectionMatrix(self):
        # ... implementation ...
        pass

    def getOrientationFromLookAt(self):
        # ... implementation ...
        pass

    def getPathName(self):
        # ... implementation ...
        pass

    def getPositionFromOrientation(self):
        # ... implementation ...
        pass

    def getProjectionMatrix(self):
        # ... implementation ...
        pass

    def getSlaves(self):
        # ... implementation ...
        pass

    def getTarget(self):
        # ... implementation ...
        pass

    def getTemplateName(self):
        # ... implementation ...
        pass

    def init(self):
        # ... implementation ...
        pass

    def reinit(self):
        # ... implementation ...
        pass

    def reset(self):
        # ... implementation ...
        pass

    def rotate(self, angle, axis):
        # ... implementation ...
        pass

    def rotateCameraAroundPoint(self, angle, axis, point):
        # ... implementation ...
        pass

    def rotateWorldAroundPoint(self, angle, axis, point):
        # ... implementation ...
        pass

    def screenToWorldPoint(self, screen_pos):
        # ... implementation ...
        pass

    def setCameraType(self, camera_type):
        # ... implementation ...
        pass

    def setDataValues(self, data_values):
        # ... implementation ...
        pass

    def setDefaultView(self):
        # ... implementation ...
        pass

    def setDefinitionSourceFileName(self, filename):
        # ... implementation ...
        pass

    def setDefinitionSourceFilePos(self, filepos):
        # ... implementation ...
        pass

    def setInstanciationSourceFileName(self, filename):
        # ... implementation ...
        pass

    def setInstanciationSourceFilePos(self, filepos):
        # ... implementation ...
        pass

    def setName(self, name):
        # ... implementation ...
        pass

    def setSrc(self, src_path):
        # ... implementation ...
        pass

    def storeResetState(self):
        # ... implementation ...
        pass

```

--------------------------------

### Prefab Methods

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/content/modules/Sofa/generated/Sofa.Core/classes/Sofa.Core.Base

This section details the methods available for interacting with Prefab objects, including getting and setting various properties and states.

```APIDOC
## Prefab Methods

### Description
Provides methods for accessing and manipulating Prefab object properties, state, and associated data.

### Methods

- **`Prefab.getLinks()`**: Retrieves links associated with the Prefab.
- **`Prefab.getLoggedMessagesAsString()`**: Gets logged messages as a string.
- **`Prefab.getMass()`**: Retrieves the mass of the Prefab.
- **`Prefab.getMechanicalMapping()`**: Gets the mechanical mapping of the Prefab.
- **`Prefab.getMechanicalState()`**: Retrieves the mechanical state.
- **`Prefab.getMeshTopology()`**: Gets the mesh topology.
- **`Prefab.getMeshTopologyLink()`**: Retrieves a specific mesh topology link.
- **`Prefab.getName()`**: Gets the name of the Prefab.
- **`Prefab.getObject()`**: Retrieves an object associated with the Prefab.
- **`Prefab.getPathName()`**: Gets the full path name of the Prefab.
- **`Prefab.getRoot()`**: Retrieves the root of the Prefab.
- **`Prefab.getRootContext()`**: Gets the root context.
- **`Prefab.getRootPath()`**: Retrieves the root path.
- **`Prefab.getState()`**: Gets the current state of the Prefab.
- **`Prefab.getTemplateName()`**: Retrieves the template name.
- **`Prefab.getTime()`**: Gets the current time.
- **`Prefab.getTopology()`**: Retrieves the topology information.
- **`Prefab.hasObject()`**: Checks if the Prefab has a specific object.
- **`Prefab.init()`**: Initializes the Prefab.
- **`Prefab.isActive()`**: Checks if the Prefab is active.
- **`Prefab.isInitialized()`**: Checks if the Prefab is initialized.
- **`Prefab.isSleeping()`**: Checks if the Prefab is sleeping.
- **`Prefab.moveChild()`**: Moves a child object.
- **`Prefab.reinit()`**: Reinitializes the Prefab.
- **`Prefab.removeChild()`**: Removes a child object.
- **`Prefab.removeObject()`**: Removes an object.
- **`Prefab.sendEvent()`**: Sends an event.
- **`Prefab.setActive()`**: Sets the active state.
- **`Prefab.setAnimate()`**: Sets the animation state.
- **`Prefab.setChangeSleepingState()`**: Sets the sleeping state change.
- **`Prefab.setDataValues()`**: Sets data values.
- **`Prefab.setDefinitionSourceFileName()`**: Sets the definition source file name.
- **`Prefab.setDefinitionSourceFilePos()`**: Sets the definition source file position.
- **`Prefab.setDt()`**: Sets the delta time.
- **`Prefab.setGravity()`**: Sets the gravity.
- **`Prefab.setInstanciationSourceFileName()`**: Sets the instanciation source file name.
- **`Prefab.setInstanciationSourceFilePos()`**: Sets the instanciation source file position.
- **`Prefab.setName()`**: Sets the name of the Prefab.
- **`Prefab.setSleeping()`**: Sets the sleeping state.
- **`Prefab.setSourceTracking()`**: Sets the source tracking.

### Attributes

- **`Prefab.objects`**: Accesses objects associated with the Prefab.
- **`Prefab.parents`**: Accesses parent objects.

```

--------------------------------

### Install NumPy and SciPy on Windows

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/_sources/content/UsingThePlugin.rst

Command to install NumPy and SciPy libraries using pip within a Windows console after setting up environment variables.

```bash
python -V && python -m pip install numpy scipy
```

--------------------------------

### Out-of-tree Build: Compiling and Installing SofaPython3

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/content/Compilation

This code snippet completes the out-of-tree build process for SofaPython3. It first builds the compiled targets using `cmake --build` and then installs the plugin to the location specified by `SP3_ROOT` using `cmake --install`.

```bash
cmake --build $SP3_BUILD
cmake --install $SP3_BUILD

```

--------------------------------

### Camera Methods

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/content/modules/Sofa/generated/Sofa.Helper/functions/Sofa.Helper.msg_info

This section details the various methods available for the Camera class, including camera setup, transformations, and coordinate conversions.

```APIDOC
## Camera Methods

### Description
Provides access to methods for controlling and querying camera properties, including setting camera types, managing view matrices, and converting between world and screen coordinates.

### Methods

- `Orthographic()`: Sets the camera to orthographic projection.
- `Perspective()`: Sets the camera to perspective projection.
- `addData()`: Adds data to the camera.
- `addLink()`: Adds a link to the camera.
- `addSlave()`: Adds a slave camera.
- `bwdInit()`: Performs backward initialization.
- `cleanup()`: Cleans up camera resources.
- `clearLoggedMessages()`: Clears logged messages.
- `computeBBox()`: Computes the bounding box.
- `countLoggedMessages()`: Counts logged messages.
- `findData()`: Finds data associated with the camera.
- `findLink()`: Finds a link associated with the camera.
- `getAsACreateObjectParameter()`: Gets parameters for creating an object.
- `getCategories()`: Retrieves the categories of the camera.
- `getClass()`: Gets the class of the camera.
- `getClassName()`: Retrieves the class name.
- `getContext()`: Gets the context of the camera.
- `getData()`: Retrieves data from the camera.
- `getDataFields()`: Gets the data fields of the camera.
- `getDefinitionSourceFileName()`: Gets the definition source file name.
- `getDefinitionSourceFilePos()`: Gets the definition source file position.
- `getInstanciationFileName()`: Gets the file name where the camera was instantiated.
- `getInstanciationSourceFilePos()`: Gets the file position where the camera was instantiated.
- `getLinkPath()`: Retrieves the path of a link.
- `getLinks()`: Gets all associated links.
- `getLoggedMessagesAsString()`: Returns logged messages as a string.
- `getLookAtFromOrientation()`: Calculates look-at target from orientation.
- `getMaster()`: Gets the master camera.
- `getModelViewMatrix()`: Retrieves the model-view matrix.
- `getName()`: Gets the name of the camera.
- `getOpenGLModelViewMatrix()`: Retrieves the OpenGL model-view matrix.
- `getOpenGLProjectionMatrix()`: Retrieves the OpenGL projection matrix.
- `getOrientationFromLookAt()`: Calculates orientation from look-at target.
- `getPathName()`: Gets the path name of the camera.
- `getPositionFromOrientation()`: Calculates position from orientation.
- `getProjectionMatrix()`: Retrieves the projection matrix.
- `getSlaves()`: Gets all slave cameras.
- `getTarget()`: Gets the camera's target.
- `getTemplateName()`: Retrieves the template name.
- `init()`: Initializes the camera.
- `reinit()`: Re-initializes the camera.
- `reset()`: Resets the camera view.
- `rotate()`: Rotates the camera.
- `rotateCameraAroundPoint()`: Rotates the camera around a specified point.
- `rotateWorldAroundPoint()`: Rotates the world around a specified point.
- `screenToWorldPoint()`: Converts screen coordinates to world coordinates.
- `setCameraType()`: Sets the camera projection type (e.g., Orthographic, Perspective).
- `setDataValues()`: Sets data values for the camera.
- `setDefaultView()`: Sets the default camera view.
- `setDefinitionSourceFileName()`: Sets the definition source file name.
- `setDefinitionSourceFilePos()`: Sets the definition source file position.
- `setInstanciationSourceFileName()`: Sets the instanciation source file name.
- `setInstanciationSourceFilePos()`: Sets the instanciation source file position.
- `setName()`: Sets the name of the camera.
- `setSrc()`: Sets the camera source.
- `storeResetState()`: Stores the current camera state for reset.
- `worldToScreenPoint()`: Converts world coordinates to screen coordinates.
```

--------------------------------

### Initialize and Access Camera Properties in Python

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/content/modules/Sofa/generated/_autosummary/_autosummary/Sofa.Core.Camera

Demonstrates how to import necessary modules, initialize the SOFA runtime, create a root node, add a camera object, and access its position and orientation properties.

```python
import Sofa.Core
import Sofa.Runtime

SofaRuntime.importPlugin("SofaComponentAll")

root = Sofa.Core.Node("root")
root.addObject("Camera", name="c")

# Access the position of the camera
print(root.c.position.value)

# Access the orientation of the camera in quaternion
print(root.c.orientation.value)
```

--------------------------------

### Executing a SOFA Simulation with runSofa

Source: https://sofapython3.readthedocs.io/en/latest/content/FirstSteps

This command initiates a SOFA simulation by loading a Python script named 'example.py' using the runSofa executable. Ensure the SofaPython3 plugin is loaded for this to work. The script 'example.py' must define a `createScene(root)` function, which is the entry point for building the SOFA scene graph.

```shell
runSofa example.py
```

--------------------------------

### Install Python and Libraries (macOS)

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/_sources/content/Installation.rst

Installs Python 3.8 using Homebrew on macOS and configures the PATH environment variable. Includes commands for installing NumPy for BigSur and Catalina systems.

```bash
brew install python@3.8
export PATH="/usr/local/opt/python@3.8/bin/:$PATH"

pip3 install --upgrade pip
python3.8 -m pip install numpy

pip3 install numpy
```

--------------------------------

### Setup SofaPython3 in runSofa

Source: https://sofapython3.readthedocs.io/en/latest/content/Compilation

Demonstrates multiple methods to load a SofaPython3 plugin built out-of-tree into the runSofa application. These include using the '-l' flag, setting the SOFA_PLUGIN_PATH environment variable, adding a repository to the scene file, or using the Plugin Manager within runSofa.

```bash
# Using the -l flag:
runSofa -l /path/to/SofaPython3_build/lib/libSofaPython3.so <scene>

# Using SOFA_PLUGIN_PATH environment variable:
export SOFA_PLUGIN_PATH=/path/to/SofaPython3_build/
runSofa <scene>

# Adding to scene file:
# <AddPluginRepository path="/path/to/SofaPython3_build/"/>

```

--------------------------------

### Set Environment Variables (Windows)

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/_sources/content/Installation.rst

Configures SOFA_ROOT, PYTHON_ROOT, PYTHONPATH, and the system Path variable on Windows. Also includes commands to verify Python version and install NumPy and SciPy.

```powershell
* Create a system variable **SOFA_ROOT** and set it to ``<SOFA-install-directory>``
* Create a system variable **PYTHON_ROOT** and set it to ``<Python3-install-directory>``
* Create a system variable **PYTHONPATH** and set it to ``%SOFA_ROOT%\plugins\SofaPython3\lib\python3\site-packages``
* Edit the system variable **Path** and add at the end ``;%PYTHON_ROOT%;%PYTHON_ROOT%\DLLs;%PYTHON_ROOT%\Lib;%SOFA_ROOT%\bin;``

Open a Console (cmd.exe) and run ``python -V && python -m pip install numpy scipy``

runSofa -lSofaPython3
```

--------------------------------

### Launch SOFA GUI with ImGui from Python

Source: https://sofapython3.readthedocs.io/en/latest/content/FirstSteps

This snippet demonstrates how to initialize and launch the SOFA ImGui (Immediate Mode Graphical User Interface) from a Python script. It sets up the scene graph, imports the necessary GUI packages, initializes the GUI manager, and starts the main simulation loop. Dependencies include the SOFA core library and the ImGui package.

```python
def main():
    # Call the SOFA function to create the root node
    root = Sofa.Core.Node("root")

    # Call the createScene function, as runSofa does
    createScene(root)

    # Once defined, initialization of the scene graph
    Sofa.Simulation.initRoot(root)

    # Import the GUI package
    import SofaImGui
    import Sofa.Gui

    # Launch the GUI (imgui is now by default, to use Qt please refer to the example "basic-useQtGui.py")
    Sofa.Gui.GUIManager.Init("myscene", "imgui")
    Sofa.Gui.GUIManager.createGUI(root, __file__)
    Sofa.Gui.GUIManager.SetDimension(1080, 800)

    # Initialization of the scene will be done here
    Sofa.Gui.GUIManager.MainLoop(root)
    Sofa.Gui.GUIManager.closeGUI()

```

--------------------------------

### Set Environment Variables (Linux/macOS)

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/_sources/content/Installation.rst

Sets the SOFA_ROOT and PYTHONPATH environment variables in the terminal for Linux and macOS. This is necessary for Python to locate SOFA components and plugins.

```bash
export SOFA_ROOT=/path/to/SOFA_install
export PYTHONPATH=/path/to/SofaPython3/lib/python3/site-packages:$PYTHONPATH
export PATH="/usr/local/opt/python@3.8/bin/:$PATH"
```

--------------------------------

### Create Scene Setup with Visual Grid

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/content/UsingThePlugin

Initializes the scene by adding a visual grid for clarity and a configuration node for plugins and scene elements. This sets up the basic structure of the SOFA scene.

```python
def createScene(rootNode):
    rootNode.addObject("VisualGrid", nbSubdiv=10, size=1000)

confignode = rootNode.addChild("Config")
confignode.addObject('OglSceneFrame', style="Arrows", alignment="TopRight")
```

--------------------------------

### Import SOFA Components in Python

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/_sources/content/Installation.rst

Python code snippet demonstrating how to import necessary SOFA modules (SofaRuntime, Sofa.Component, Sofa.Core) to interact with SOFA objects and run simulations.

```python
# to be able to create SOFA objects you need to first load the plugins that implement them.
# For simplicity you can load the plugin "Sofa.Component" that will load all most
# common sofa objects.
import SofaRuntime
SofaRuntime.importPlugin("Sofa.Component")

# to create elements like Node or objects
import Sofa.Core
```

--------------------------------

### Full SOFA Scene Setup (Python)

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/content/FirstSteps

Provides the complete Python code for setting up a SOFA scene. This includes importing SOFA modules, defining the main function to create the root node, calling a createScene function (not shown), initializing the simulation, and launching the graphical user interface.

```python
import Sofa
import Sofa.Gui

def main():
# Call the SOFA function to create the root node
root = Sofa.Core.Node("root")

# Call the createScene function, as runSofa does
createScene(root)

# Once defined, initialization of the scene graph
Sofa.Simulation.init(root)

# Launch the GUI (qt or qglviewer)
Sofa.Gui.GUIManager.Init("myscene", "qglviewer")
Sofa.Gui.GUIManager.createGUI(root, __file__)
Sofa.Gui.GUIManager.SetDimension(1080, 800)

```

--------------------------------

### Initialize and Run SOFA Simulation

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/_sources/content/UsingThePlugin.rst

This snippet demonstrates the basic workflow for setting up a SOFA simulation. It involves creating a root node, defining the scene graph, initializing the simulation, running it for a set number of steps, and printing the position of a sphere. It also shows how to modify gravity and rerun the simulation.

```python
import Sofa

# Call the SOFA function to create the root node
root = Sofa.Core.Node("root")

# Call the createScene function, as runSofa does
createScene(root)

# Once defined, initialization of the scene graph
Sofa.Simulation.init(root)

# Run the simulation for 10 steps
for iteration in range(10):
        Sofa.Simulation.animate(root, root.dt.value)

# Print the position of the falling sphere
print(root.sphere.mstate.position.value)

# Increase the gravity
root.gravity.value = [0, 0, 0]

# Run the simulation for 10 steps MORE
for iteration in range(10):
        Sofa.Simulation.animate(root, root.dt.value)

# Print the position of the falling sphere
print(root.sphere.mstate.position.value)
```

--------------------------------

### Get Instantiation Source File Information in SofaPython3

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/content/modules/Sofa/generated/Sofa.Core/classes/Sofa.Core.Node

Retrieves the source file name and line number where a Sofa object was instantiated. This aids in tracking the creation of objects during simulation setup.

```python
getInstanciationFileName(_self : Sofa.Core.Base_) → str

Returns the line number where the object is instanciated.
```

```python
getInstanciationSourceFilePos(_self : Sofa.Core.Base_) → int

Returns the line number where the object is instanciated.
```

--------------------------------

### Python Example: Creating and Accessing a SOFA Link

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/content/modules/Sofa/generated/Sofa.Core/classes/Sofa.Core.Link

Demonstrates how to create a Node, add a component with a mechanical object, find a link to that object, and retrieve its value or help message. This snippet requires the Sofa.Core and SofaRuntime modules, and the SofaComponentAll plugin.

```python
import Sofa.Core
import SofaRuntime

SofaRuntime.importPlugin("SofaComponentAll")

root = Sofa.Core.Node("root")
root.addObject("MechanicalObject", name="t")

link = root.findLink("mechanicalState") # access the link

print(link.getValueString()) # will print '@/t'
print(link.getHelp()) # will print the help message for all mechanical states
```

--------------------------------

### Initialization and Re-initialization of MassRigid2d in Python

Source: https://sofapython3.readthedocs.io/en/latest/content/modules/Sofa/generated/Sofa.Helper/functions/Sofa.Helper.msg_info

init() performs the initial setup and configuration of the MassRigid2d object. reinit() re-initializes the object, often used after significant changes to the scene or simulation parameters. These are critical for starting and resetting simulations.

```python
mass_rigid.init()
```

```python
mass_rigid.reinit()
```

--------------------------------

### Get Object Path Name - Python

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/content/modules/Sofa/generated/Sofa.Core/classes/Sofa.Core.Context

Retrieves the full path name of a Sofa object within the scene graph. This is useful for identifying and accessing specific nodes or objects in a hierarchical structure. The example demonstrates creating a node and then retrieving its path name.

```python
a = Sofa.Core.Node("root")
b = a.addObject("Camera", name="camera")
b.getPathName() # should returns "/root/camera"

```

--------------------------------

### Install Python 3.8 and NumPy (macOS)

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/content/UsingThePlugin

Commands to install Python 3.8 and NumPy on macOS. This includes setting the PATH environment variable to use the installed Python version.

```bash
brew install python@3.8
export PATH="/usr/local/opt/python@3.8/bin/:$PATH"
```

--------------------------------

### Import SOFA Plugins and Initialize Simulation (Python)

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/_modules/Sofa

This snippet demonstrates how to import SOFA plugins, create a node, add a mechanical object, and initialize the SOFA simulation. It requires the Sofa.Core, Sofa.Simulation, and SofaRuntime modules.

```python
import Sofa.Core
import Sofa.Simulation
import SofaRuntime
SofaRuntime.importPlugin("Sofa.Component")

n = Sofa.Core.Node("MyNode")
n.addChild("Node2")
n.addObject("MechanicalObject", name="dofs")

Sofa.Simulation.init(n)
Sofa.Simulation.print(n)
```

--------------------------------

### Install Python 3.12 and numpy on Ubuntu

Source: https://sofapython3.readthedocs.io/en/latest/content/Installation

Installs Python 3.12, pip, and the numpy library on Ubuntu systems. It also includes a command to install libopengl0 if runSofa is intended to be launched.

```bash
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt install libpython3.12 python3.12 python3-pip
python3.12 -m pip install numpy
sudo apt install libopengl0
```

--------------------------------

### Executing a SOFA Simulation with python3 Interpreter

Source: https://sofapython3.readthedocs.io/en/latest/content/FirstSteps

This command executes a Python script named 'example.py' using the python3 interpreter. Before running, ensure that the SOFA Python modules' path is added to your PYTHONPATH environment variable. The script should contain the `createScene` function and typically a `main` function for setup and simulation execution.

```shell
python3 example.py
```

--------------------------------

### Initialize and Launch SOFA Scene with ImGui

Source: https://sofapython3.readthedocs.io/en/latest/content/FirstSteps

This Python code initializes a SOFA scene, sets up the GUI using ImGui, and launches the simulation. It defines the root node, calls a createScene function (not shown), initializes the simulation environment, and configures the GUI window dimensions.

```python
import Sofa
import SofaImGui
import Sofa.Gui

def main():
    # Call the SOFA function to create the root node
    root = Sofa.Core.Node("root")

    # Call the createScene function, as runSofa does
    createScene(root)

    # Once defined, initialization of the scene graph
    Sofa.Simulation.initRoot(root)

    # Launch the GUI (imgui is now by default, to use Qt please refer to the example "basic-useQtGui.py")
    Sofa.Gui.GUIManager.Init("myscene", "imgui")
    Sofa.Gui.GUIManager.createGUI(root, __file__)
    Sofa.Gui.GUIManager.SetDimension(1080, 800)

```

--------------------------------

### Install Python 3.12 and numpy on macOS

Source: https://sofapython3.readthedocs.io/en/latest/content/Installation

Installs Python 3.12 using Homebrew and configures the PATH environment variable. It also installs numpy for Python 3.12, with specific instructions for BigSur and Catalina.

```bash
brew install python@3.12
export PATH="/usr/local/opt/python@3.12/bin/:$PATH"
pip3 install --upgrade pip
python3.12 -m pip install numpy
```

--------------------------------

### Install Python 3.8 and NumPy on macOS

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/_sources/content/UsingThePlugin.rst

Commands to install Python 3.8 using Homebrew and install the NumPy library on macOS. Also includes setting the PATH environment variable.

```bash
brew install python@3.8
export PATH="/usr/local/opt/python@3.8/bin/:$PATH"
pip3 install --upgrade pip
python3.8 -m pip install numpy
```

--------------------------------

### Install NumPy (macOS BigSur)

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/content/UsingThePlugin

Commands to upgrade pip and install NumPy for macOS BigSur.

```bash
pip3 install --upgrade pip
python3.8 -m pip install numpy
```

--------------------------------

### Initialize and Print Sofa Scene (Python)

Source: https://sofapython3.readthedocs.io/en/latest/content/modules/Sofa/generated/Sofa.Simulation

This code snippet demonstrates how to initialize a Sofa scene and print its structure using the Sofa.Simulation module. It requires importing Sofa.Core and SofaRuntime, and also importing the 'SofaComponentAll' plugin. The function takes a Sofa.Core.Node as input.

```python
import Sofa.Core
import SofaRuntime
SofaRuntime.importPlugin("SofaComponentAll")

n = Sofa.Core.Node("MyNode")
Sofa.Simulation.init(n)
Sofa.Simulation.print(n)

```

--------------------------------

### Install NumPy on macOS (Catalina)

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/_sources/content/UsingThePlugin.rst

Specific command to install the NumPy library on macOS Catalina.

```bash
pip3 install numpy
```

--------------------------------

### bwdInit Method

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/content/modules/Sofa/generated/Sofa.Core/classes/Sofa.Core.Object

Documentation for the `bwdInit` method, responsible for bottom-up initialization during graph creation and modification.

```APIDOC
## bwdInit

### Description
Initialization method called at graph creation and modification, during bottom-up traversal.

### Parameters
- **self** (Sofa.Core.Object): The object to initialize.

### Returns
- None
```

--------------------------------

### Initialize SOFA Scene and GUI

Source: https://sofapython3.readthedocs.io/en/latest/content/FirstSteps

This snippet shows the initial steps to start and manage the SOFA GUI, including launching the main event loop and closing the GUI. It relies on the Sofa.Gui.GUIManager module. There are no explicit inputs or outputs shown for these calls, and they are typically used at the beginning and end of a SOFA application's interaction with the graphical interface.

```python
Sofa.Gui.GUIManager.MainLoop(root)
Sofa.Gui.GUIManager.closeGUI()
```

--------------------------------

### Get Root Context in Python

Source: https://sofapython3.readthedocs.io/en/latest/content/modules/Sofa/generated/Sofa.Core/classes/Sofa.Core.BaseContext

Gets the root context of the Sofa graph. This function is essential for navigating to the top level of the simulation scene hierarchy.

```python
getRootContext(_self : Sofa.Core.BaseContext_) → Sofa.Core.BaseContext # Get the root context of the graph
```

--------------------------------

### Install Python 3.8 and NumPy on Ubuntu

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/_sources/content/UsingThePlugin.rst

Commands to install Python 3.8, pip, and the NumPy library on Ubuntu. This is a prerequisite for using SofaPython3.

```bash
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt install libpython3.8 python3.8 python3-pip
python3.8 -m pip install numpy
```

--------------------------------

### Get Object Class Name in Sofa

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/content/modules/Sofa/generated/Sofa.SofaConstraintSolver/classes/Sofa.SofaConstraintSolver.ConstraintSolverImpl

Gets the name of the class of a Sofa Base object as a string. This provides a simple string representation of the object's type.

```python
getClassName(_self : Sofa.Core.Base_) → str
```

--------------------------------

### Launch SOFA GUI from Python Script (Python)

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/content/FirstSteps

This Python code snippet shows how to integrate SOFA's graphical user interface (GUI) into a simulation script. After initializing the scene, it uses Sofa.Gui.GUIManager to set up and launch the GUI, allowing for interactive simulation management. This is an alternative to running simulations headlessly.

```python
def main():
# Call the SOFA function to create the root node
root = Sofa.Core.Node("root")

# Call the createScene function, as runSofa does
createScene(root)

# Once defined, initialization of the scene graph
Sofa.Simulation.init(root)

# Launch the GUI (qt or qglviewer)
Sofa.Gui.GUIManager.Init("myscene", "qglviewer")
Sofa.Gui.GUIManager.createGUI(root, __file__)
Sofa.Gui.GUIManager.SetDimension(1080, 800)

```

--------------------------------

### Prefab Methods

Source: https://sofapython3.readthedocs.io/en/latest/content/modules/Sofa/generated/Sofa.Helper/classes/Sofa.Helper.StdVectorfloat

This section details the methods available for the Prefab class, allowing interaction with object instantiation, state management, and data retrieval.

```APIDOC
## Prefab Class Methods

### Description
Provides access to various properties and functionalities of a Prefab object, including its state, associated data, and relationships with other objects.

### Methods
* `Prefab.getInstanciationSourceFilePos()`
* `Prefab.getLinkPath()`
* `Prefab.getLinks()`
* `Prefab.getLoggedMessagesAsString()`
* `Prefab.getMass()`
* `Prefab.getMechanicalMapping()`
* `Prefab.getMechanicalState()`
* `Prefab.getMeshTopology()`
* `Prefab.getMeshTopologyLink()`
* `Prefab.getName()`
* `Prefab.getObject()`
* `Prefab.getPathName()`
* `Prefab.getRoot()`
* `Prefab.getRootContext()`
* `Prefab.getRootPath()`
* `Prefab.getState()`
* `Prefab.getTemplateName()`
* `Prefab.getTime()`
* `Prefab.getTopology()`
* `Prefab.hasODESolver()`
* `Prefab.hasObject()`
* `Prefab.init()`
* `Prefab.isActive()`
* `Prefab.isInitialized()`
* `Prefab.isSleeping()`
* `Prefab.moveChild()`
* `Prefab.reinit()`
* `Prefab.removeChild()`
* `Prefab.removeObject()`
* `Prefab.sendEvent()`
* `Prefab.setActive()`
* `Prefab.setAnimate()`
* `Prefab.setChangeSleepingState()`
* `Prefab.setDataValues()`
* `Prefab.setDefinitionSourceFileName()`
* `Prefab.setDefinitionSourceFilePos()`
* `Prefab.setDt()`
* `Prefab.setGravity()`
* `Prefab.setInstanciationSourceFileName()`
* `Prefab.setInstanciationSourceFilePos()`
* `Prefab.setName()`
* `Prefab.setSleeping()`
* `Prefab.setSourceTracking()`

### Properties
* `Prefab.objects`
* `Prefab.parents

### Example
```python
# Example usage (conceptual)
prefab_instance = Prefab()
prefab_instance.init()
print(prefab_instance.getName())
```
```

--------------------------------

### Prefab Methods for Object and State Management

Source: https://sofapython3.readthedocs.io/en/latest/content/modules/Sofa/additionalmodules

Provides methods to interact with Prefab objects, including getting and setting various properties like name, state, mass, and links. Also includes methods for initialization, reinitialization, and managing object relationships.

```python
import Sofa

# Example usage of some Prefab methods (conceptual)
prefab = Sofa.getPrefab("MyPrefab")

# Getting information
print(prefab.getName())
print(prefab.getMass())
print(prefab.getState())
print(prefab.getLinks())

# Setting information
prefab.setName("NewPrefabName")
prefab.setActive(True)
prefab.setSleeping(False)
prefab.setDataValues({"key": "value"})

# Initialization and state management
prefab.init()
prefab.reinit()
print(prefab.isInitialized())
print(prefab.isActive())
print(prefab.isSleeping())

# Object and relationship management
object = prefab.getObject("MyObject")
prefab.removeObject(object)
prefab.moveChild(old_parent, new_parent)
print(prefab.parents)
print(prefab.objects)

# Source file information
prefab.setDefinitionSourceFileName("my_file.py")
print(prefab.getDefinitionSourceFileName())
prefab.setInstanciationSourceFilePos(10)
print(prefab.getInstanciationSourceFilePos())

# Logging and animation
print(prefab.getLoggedMessagesAsString())
prefab.setAnimate(True)

# Mechanical state and mapping
print(prefab.getMechanicalState())
print(prefab.getMechanicalMapping())

# Topology and mesh
print(prefab.getTopology())
print(prefab.getMeshTopology())
print(prefab.getMeshTopologyLink())

# Other methods
prefab.sendEvent(event)
prefab.setDt(0.01)
prefab.setGravity([0, -9.81, 0])
prefab.setSourceTracking(True)
print(prefab.hasODESolver())
print(prefab.hasObject("MyObject"))
print(prefab.getTemplateName())
print(prefab.getTime())
print(prefab.getRoot())
print(prefab.getRootContext())
print(prefab.getRootPath())
print(prefab.getInstanciationSourceFilePos())
print(prefab.getLinkPath())
print(prefab.getLoggedMessagesAsString())
print(prefab.getMechanicalMapping())
print(prefab.getMechanicalState())
print(prefab.getMeshTopology())
print(prefab.getMeshTopologyLink())
print(prefab.getName())
print(prefab.getObject())
print(prefab.getPathName())
print(prefab.getRoot())
print(prefab.getRootContext())
print(prefab.getRootPath())
print(prefab.getState())
print(prefab.getTemplateName())
print(prefab.getTime())
print(prefab.getTopology())
print(prefab.hasODESolver())
print(prefab.hasObject())
print(prefab.init())
print(prefab.isActive())
print(prefab.isInitialized())
print(prefab.isSleeping())
print(prefab.moveChild())
print(prefab.objects)
print(prefab.parents)
print(prefab.reinit())
print(prefab.removeChild())
print(prefab.removeObject())
print(prefab.sendEvent())
print(prefab.setActive())
print(prefab.setAnimate())
print(prefab.setChangeSleepingState())
print(prefab.setDataValues())
print(prefab.setDefinitionSourceFileName())
print(prefab.setDefinitionSourceFilePos())
print(prefab.setDt())
print(prefab.setGravity())
print(prefab.setInstanciationSourceFileName())
print(prefab.setInstanciationSourceFilePos())
print(prefab.setName())
print(prefab.setSleeping())
print(prefab.setSourceTracking())

```

--------------------------------

### Initialize and Print SOFA Scene Node (Python)

Source: https://sofapython3.readthedocs.io/en/latest/content/modules/Sofa/index

This code snippet demonstrates how to initialize a SOFA scene graph starting from a root node, add child nodes, attach components, and then print the scene structure. It requires the Sofa.Core, Sofa.Simulation, and SofaRuntime modules.

```python
import Sofa.Core
import Sofa.Simulation
import SofaRuntime
SofaRuntime.importPlugin("Sofa.Component")

n = Sofa.Core.Node("MyNode")
n.addChild("Node2")
n.addObject("MechanicalObject", name="dofs")

Sofa.Simulation.init(n)
Sofa.Simulation.print(n)

```

--------------------------------

### RegularGridTopology - getClassName

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/content/modules/Sofa/generated/Sofa.SofaBaseTopology/classes/Sofa.SofaBaseTopology.RegularGridTopology

Get the name of the class of the Base.

```APIDOC
## RegularGridTopology - getClassName

### Description
Get the name of the class of the Base.

### Method
GET

### Endpoint
/websites/sofapython3_readthedocs_io_en/Sofa/SofaBaseTopology/RegularGridTopology

### Parameters
#### Path Parameters
None

#### Query Parameters
None

### Request Example
None

### Response
#### Success Response (200)
- **class_name** (str) - The name of the class.

#### Response Example
```json
{
  "class_name": "RegularGridTopology"
}
```
```

--------------------------------

### Prefab Class Methods

Source: https://sofapython3.readthedocs.io/en/v24.12.00-doc-generation/content/modules/Sofa/generated/Sofa.SofaGL/functions/Sofa.SofaGL.draw

This section details the available methods for interacting with the Prefab class, covering operations like getting information, initialization, state management, and object manipulation.

```APIDOC
## Prefab Class Methods

### Description
Methods for interacting with the Prefab class, including getting various properties, initializing, managing state, and manipulating objects.

### Methods
- `Prefab.getLinks()`
- `Prefab.getLoggedMessagesAsString()`
- `Prefab.getMass()`
- `Prefab.getMechanicalMapping()`
- `Prefab.getMechanicalState()`
- `Prefab.getMeshTopology()`
- `Prefab.getMeshTopologyLink()`
- `Prefab.getName()`
- `Prefab.getObject()`
- `Prefab.getPathName()`
- `Prefab.getRoot()`
- `Prefab.getRootContext()`
- `Prefab.getRootPath()`
- `Prefab.getState()`
- `Prefab.getTemplateName()`
- `Prefab.getTime()`
- `Prefab.getTopology()`
- `Prefab.hasObject()`
- `Prefab.init()`
- `Prefab.isActive()`
- `Prefab.isInitialized()`
- `Prefab.isSleeping()`
- `Prefab.moveChild()`
- `Prefab.objects` (Property)
- `Prefab.parents` (Property)
- `Prefab.reinit()`
- `Prefab.removeChild()`
- `Prefab.removeObject()`
- `Prefab.sendEvent()`
- `Prefab.setActive()`
- `Prefab.setAnimate()`
- `Prefab.setChangeSleepingState()`
- `Prefab.setDataValues()`
- `Prefab.setDefinitionSourceFileName()`
- `Prefab.setDefinitionSourceFilePos()`
- `Prefab.setDt()`
- `Prefab.setGravity()`
- `Prefab.setInstanciationSourceFileName()`
- `Prefab.setInstanciationSourceFilePos()`
- `Prefab.setName()`
- `Prefab.setSleeping()`
- `Prefab.setSourceTracking()`
```

--------------------------------

### Sofa.Core.Base - getTemplateName

Source: https://sofapython3.readthedocs.io/en/latest/content/modules/Sofa/generated/Sofa.Core/classes/Sofa.Core.Base

Get the name of the template of the Base.

```APIDOC
## GET /getTemplateName

### Description
Get the name of the template of the Base.

### Method
GET

### Endpoint
/getTemplateName

### Parameters
#### Query Parameters
- **_self** (Sofa.Core.Base_) - Required - The Sofa.Core.Base object to get the template name of.

### Response
#### Success Response (200)
- **templateName** (string) - The name of the template of the Base.
```
Tokens:
Raw