cuMotion

https://nvidia-isaac.github.io/cumotion/
Admin
NVIDIA cuMotion is a high-performance GPU-accelerated motion generation library for robotics that...
Tokens:144,476
Snippets:1,167
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Build cuMotion Examples on Linux (Default Path)

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Builds the cuMotion examples on Linux when cuMotion is installed in the default path (e.g., /opt/cumotion/). Navigates to the examples directory, configures CMake, and builds the project.

```bash
cd examples && \
    cmake -B build . && \
    cmake --build build

```

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

### Install cuMotion Python Example Dependencies

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Installs the necessary Python dependencies for running cuMotion examples after navigating to the python/examples directory.

```bash
cd python/examples
pip install -r requirements.txt

```

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

### Run cuMotion Example Executable

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Executes a built cuMotion example, such as 'franka_trajectory_optimizer_obstacle_example', from the build directory.

```bash
cd build && \
    ./franka_trajectory_optimizer_obstacle_example

```

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

### Build cuMotion Examples on Linux (Custom Path)

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Builds the cuMotion examples on Linux when cuMotion is installed in a custom path. Requires setting the cumotion_ROOT environment variable or CMake cache variable.

```bash
cd examples && \
    cmake -Dcumotion_ROOT=$CUMOTION_ROOT -B build . && \
    cmake --build build

```

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

### Load Robot and Setup World (Python)

Source: https://nvidia-isaac.github.io/cumotion/tutorials/inverse_kinematics_tutorial.html

Loads a robot description and kinematics model in Python, then creates a world. This is a Python equivalent to the C++ setup.

```Python
robot_description: cumotion.RobotDescription = cumotion.load_robot_from_file(xrdf_path, urdf_path)
kinematics: cumotion.Kinematics = robot_description.kinematics()

# Create a world.
world = cumotion.create_world()

# Add a world view.
world_view = world.add_world_view()

# Get the tool frame name.
tool_frame_name = robot_description.tool_frame_names()[0]

# Compute the tool frame pose at the default c-space configuration.
default_cspace = robot_description.default_cspace_configuration()
default_tool_pose = kinematics.pose(default_cspace, tool_frame_name)


```

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

### Run cuMotion Example Executable on Windows

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Executes a built cuMotion example on Windows from the Release build directory.

```bash
build\Release\franka_trajectory_optimizer_obstacle_example.exe

```

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

### Build cuMotion Examples on Windows

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Builds the cuMotion examples on Windows. Requires setting cumotion_ROOT and Eigen3_ROOT environment variables or CMake cache variables.

```bash
cd examples
cmake -Dcumotion_ROOT=$env:CUMOTION_ROOT -DEigen3_ROOT=<eigen_install_path> -B build .
cmake --build build --config Release

```

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

### Run cuMotion Python Example

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Executes a Python example script for cuMotion, such as the trajectory optimizer example.

```python
python trajectory_optimizer_examples/franka_trajectory_optimizer_obstacle_example.py

```

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

### Build cuMotion Examples on Windows (Explicit CUDA Path)

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Builds cuMotion examples on Windows, explicitly specifying the CUDA path if the compiler is not found automatically. Requires setting cumotion_ROOT and Eigen3_ROOT.

```bash
cmake -Dcumotion_ROOT=$env:CUMOTION_ROOT -DEigen3_ROOT=<eigen_install_path> -DCUDA_PATH=$CUDA_PATH -B build .

```

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

### Install cuMotion Test Dependencies

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Install the necessary Python packages for running tests. Ensure your virtual environment is activated.

```bash
pip install -r python/tests/requirements.txt
```

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

### Install Custom cuMotion Logger

Source: https://nvidia-isaac.github.io/cumotion/api/cpp_api.html

Install a custom logger by providing a shared pointer to a Logger-derived object. Pass nullptr to re-enable the default logger.

```cpp
cumotion::SetLogger(std::make_shared<MyCustomLogger>());

```

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

### Install cuMotion Visualization Package on Windows

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Installs the optional cuMotion visualization package on Windows via pip. This package is required for visualizing example outputs.

```powershell
pip install (Get-Item ../../python_wheels/cumotion_vis-*.whl)

```

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

### Install cuMotion Visualization Package on Linux

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Installs the optional cuMotion visualization package on Linux via pip. This package is required for visualizing example outputs.

```bash
pip install ../../python_wheels/cumotion_vis-*.whl

```

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

### Install Eigen on Debian/Ubuntu

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Installs the Eigen library, a dependency for cuMotion, on Debian or Ubuntu systems using apt.

```bash
sudo apt install -y libeigen3-dev

```

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

### Install cuMotion Visualization Package on Linux

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Installs the optional 'cumotion_vis' Python package for visualization helpers. This package may have installation issues on Jetson or DGX Spark.

```bash
pip install python_wheels/cumotion_vis-*.whl

```

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

### Create and Activate Virtual Environment on Linux

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Creates a Python virtual environment named '.venv' and activates it. This is recommended before installing Python packages.

```bash
python -m venv .venv && \
    source .venv/bin/activate

```

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

### Set Obstacle Attribute Example

Source: https://nvidia-isaac.github.io/cumotion/api/cpp_api.html

Demonstrates how to set attributes for an obstacle using `setAttribute()`. Ensure the attribute and value type are compatible with the obstacle type.

```cpp
virtual void setAttribute( 
    _Attribute attribute_,     _const AttributeValue &value_ ) = 0#  
    
Set attribute for obstacle.
Available attributes are based on the `Obstacle::Type` and detailed in documentation for `Obstacle::Type`.
Example usage: my_sphere.setAttribute(Obstacle::Attribute::RADIUS, 3.0); my_cuboid.setAttribute(Obstacle::Attribute::SIDE_LENGTHS, Eigen::Vector3d(2.0, 3.0, 1.0));  
```

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

### Build and Install Eigen on Windows

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Builds and installs Eigen 3.4.0 on Windows. Eigen is a header-only library, so this process primarily involves copying headers and generating CMake configuration files.

```bash
cd eigen-3.4.0
cmake -B build -DCMAKE_INSTALL_PREFIX=<eigen_install_path>
cmake --build build --target install

```

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

### Get Default C-Space Configuration (Python)

Source: https://nvidia-isaac.github.io/cumotion/tutorials/robot_description_tutorial.html

Retrieves and prints the default configuration for the robot's c-space.

```python
default_cspace_position = robot_description.default_cspace_configuration()
print("Default position: ", default_cspace_position)

```

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

### Plan to Task-Space Target (Python)

Source: https://nvidia-isaac.github.io/cumotion/tutorials/trajectory_optimization_tutorial.html

Plans a trajectory to a specified task-space target using Python, such as a position 20 cm below a previous target. Requires kinematics and optimizer setup.

```Python
# Plan to a task-space target 20 cm below the target c-space position.
target_tool_position = kinematics.position(target_cspace_position, tool_frame_name)
new_target_position = target_tool_position - np.array([0.0, 0.0, 0.2])

translation_constraint = cumotion.TrajectoryOptimizer.TranslationConstraint.target(
    new_target_position)
task_space_target = cumotion.TrajectoryOptimizer.TaskSpaceTarget(translation_constraint)

print("\nTask-space goal:")
results = optimizer.plan_to_task_space_target(target_cspace_position, task_space_target)
print_status(results)

```

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

### Get Default C-Space Configuration (C++)

Source: https://nvidia-isaac.github.io/cumotion/tutorials/robot_description_tutorial.html

Retrieves and prints the default configuration for the robot's c-space.

```cpp
Eigen::VectorXd default_cspace_position = robot_description->defaultCSpaceConfiguration();
std::cout << "Default position: [" << default_cspace_position.transpose() << "]\n";

```

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

### Plan to Task-Space Target (C++)

Source: https://nvidia-isaac.github.io/cumotion/tutorials/trajectory_optimization_tutorial.html

Plans a trajectory to a specified task-space target, such as a position 20 cm below a previous target. Requires kinematics and optimizer setup.

```C++
// Plan to a task-space target 20 cm below the target c-space position.
Eigen::Vector3d target_tool_position =
    kinematics->position(target_cspace_position, kinematics->frame(tool_frame_name));
Eigen::Vector3d new_target_position = target_tool_position - Eigen::Vector3d(0.0, 0.0, 0.2);

cumotion::TrajectoryOptimizer::TranslationConstraint translation_constraint =
    cumotion::TrajectoryOptimizer::TranslationConstraint::Target(new_target_position);
cumotion::TrajectoryOptimizer::TaskSpaceTarget task_space_target(translation_constraint);

std::cout << "\nTask-space goal:\n";
results = optimizer->planToTaskSpaceTarget(target_cspace_position, task_space_target);
print_status(*results);

```

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

### Verify IK Solutions with Forward Kinematics (C++)

Source: https://nvidia-isaac.github.io/cumotion/tutorials/inverse_kinematics_tutorial.html

Iterates through IK solutions, uses forward kinematics to get the resulting pose, and calculates the distance to the intended target. This verifies the accuracy of the IK solution.

```cpp
// Print table header
std::cout << "\n"
            << std::left << std::setw(18) << "Solution Index" << std::setw(18) << "Target Index"
            << "Position Error (um)\n";
std::cout << std::string(54, '-') << "\n";

for (size_t i = 0; i < goalset_cspace_positions.size(); ++i) {
    int target_idx = target_indices[i];

    // Compute the forward kinematics for this solution.
    cumotion::Pose3 solution_pose = kinematics->pose(goalset_cspace_positions[i], tool_frame);

    // Compute the distance to the indicated target.
    double distance_to_target =
        (solution_pose.translation - translation_targets[target_idx]).norm();

    // Convert to micrometers and print row
    double error_um = distance_to_target * 1e6;
    std::cout << std::left << std::setw(18) << i << std::setw(18) << target_idx << std::fixed
            << std::setprecision(2) << error_um << "\n";
}
```

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

### Install cuMotion Visualization Package on Windows

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Installs the optional 'cumotion_vis' Python package for visualization helpers using PowerShell. This package may have installation issues on Jetson or DGX Spark.

```powershell
pip install (Get-Item python_wheels/cumotion_vis-*.whl)

```

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

### Load Robot and Setup World

Source: https://nvidia-isaac.github.io/cumotion/tutorials/inverse_kinematics_tutorial.html

Loads a robot description and kinematics model, then creates a world with a cuboid obstacle positioned near the robot's default tool frame pose. Ensure robot and URDF files are correctly specified.

```C++
std::unique_ptr<cumotion::RobotDescription> robot_description = 
    cumotion::LoadRobotFromFile(xrdf_file, urdf_file);
std::unique_ptr<cumotion::Kinematics> kinematics = robot_description->kinematics();
assert(robot_description != nullptr);
assert(kinematics != nullptr);

// Create a world.
std::shared_ptr<cumotion::World> world = cumotion::CreateWorld();

// Add a world view.
cumotion::WorldViewHandle world_view = world->addWorldView();

// Get the tool frame name.
std::string tool_frame_name = robot_description->toolFrameNames().front();
cumotion::Kinematics::FrameHandle tool_frame = kinematics->frame(tool_frame_name);

// Compute the tool frame pose at the default c-space configuration.
Eigen::VectorXd default_cspace = robot_description->defaultCSpaceConfiguration();
cumotion::Pose3 default_tool_pose = kinematics->pose(default_cspace, tool_frame);

// Create a cuboid obstacle near the initial position of the tool frame.
std::unique_ptr<cumotion::Obstacle> cuboid = 
    cumotion::CreateObstacle(cumotion::Obstacle::Type::CUBOID);
cuboid->setAttribute(cumotion::Obstacle::Attribute::SIDE_LENGTHS, Eigen::Vector3d(0.2, 0.4, 0.2));

// Position the obstacle slightly offset from the default tool position.
Eigen::Vector3d obstacle_position = default_tool_pose.translation;
obstacle_position.y() += 0.3;  // Offset in the y-direction
cumotion::Pose3 obstacle_pose = cumotion::Pose3::FromTranslation(obstacle_position);

// Add the obstacle to the world.
cumotion::World::ObstacleHandle obstacle_handle = world->addObstacle(*cuboid, obstacle_pose);

```

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

### Create IK Solver Instance

Source: https://nvidia-isaac.github.io/cumotion/tutorials/inverse_kinematics_tutorial.html

Instantiate the IK solver using the configured parameters. This is an expensive operation that allocates host and device memory. Once created, solver parameters cannot be modified.

```cpp
std::unique_ptr<cumotion::CollisionFreeIkSolver> ik_solver =
    cumotion::CreateCollisionFreeIkSolver(*config);

```

```python
ik_solver = cumotion.create_collision_free_ik_solver(config)

```

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

### CreateMotionPlannerConfigFromFile

Source: https://nvidia-isaac.github.io/cumotion/api/cpp_api.html

Loads a set of MotionPlanner configuration parameters from a file. These parameters are combined with robot description, tool frame name, and world view to create a configuration for motion planning. A fatal error will be logged if the config file is missing required parameters. Invalid parameter values will be clipped or logged as fatal errors.

```APIDOC
## CreateMotionPlannerConfigFromFile

### Description
Loads a set of `MotionPlanner` configuration parameters from a file. These parameters are combined with `robot_description`, `tool_frame_name`, and `world_view` to create a configuration for motion planning. A fatal error will be logged if `motion_planner_config_file` is missing any required parameters. If any provided parameter values are invalid:
  * When recoverable, they will be clipped to their expected value range with a warning on calling `CreateMotionPlanner()`.
  * When not recoverable, a fatal error will be logged.

A configuration will _NOT_ be created if:
  1. `robot_description` is invalid, _OR_
  2. `tool_frame_name` is not a valid frame in `robot_description`. In the case of failure, a non-fatal error will be logged and a `nullptr` will be returned.

### Function Signature
std::unique_ptr<MotionPlannerConfig> cumotion::CreateMotionPlannerConfigFromFile(
    _const std::filesystem::path &motion_planner_config_file_,
    _const RobotDescription &robot_description_,
    _const std::string &tool_frame_name_,
    _const WorldViewHandle &world_view_ )
```

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

### create_motion_planner_config_from_file

Source: https://nvidia-isaac.github.io/cumotion/api/python_api.html

Load a set of motion planning parameters from file and construct a MotionPlannerConfig.

```APIDOC
cumotion.create_motion_planner_config_from_file( 
    _motion_planner_config_file : os.PathLike | str | bytes_,     _robot_description : cumotion::RobotDescription_,     _tool_frame_name : str_,     _world_view : cumotion::WorldViewHandle_, ) → cumotion.cumotion.MotionPlannerConfig#     
Load a set of motion planning parameters from file and construct a MotionPlannerConfig.
```

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

### Check cuMotion Python Package Installation

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Verifies if the cuMotion Python package is installed in the current local environment using pip.

```bash
pip show cumotion

```

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

### Create RmpFlowConfig from File

Source: https://nvidia-isaac.github.io/cumotion/api/cpp_api.html

Load RMPflow parameters from a file. Requires robot description and world view.

```cpp
std::unique_ptr<RmpFlowConfig> cumotion::CreateRmpFlowConfigFromFile(
    _const std::filesystem::path &rmpflow_config_file_,
    _const RobotDescription &robot_description_,
    _const WorldViewHandle &world_view_ );

```

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

### Load Robot and Set Up World with Obstacle (C++)

Source: https://nvidia-isaac.github.io/cumotion/tutorials/trajectory_optimization_tutorial.html

Loads a UR10 robot description, creates a world with a world view, and adds a cuboid obstacle near the robot's tool frame. This is a foundational step for trajectory optimization.

```cpp
// Load the UR10 robot description.
std::unique_ptr<cumotion::RobotDescription> robot_description =
    cumotion::LoadRobotFromFile(xrdf_file, urdf_file);
assert(robot_description != nullptr);

// Get the tool frame name and default c-space position.
std::string tool_frame_name = robot_description->toolFrameNames().front();
Eigen::VectorXd initial_cspace_position = robot_description->defaultCSpaceConfiguration();

// Create a world and add a world view.
std::shared_ptr<cumotion::World> world = cumotion::CreateWorld();
cumotion::WorldViewHandle world_view = world->addWorldView();

// Create a cuboid obstacle near the end effector.
std::unique_ptr<cumotion::Kinematics> kinematics = robot_description->kinematics();
Eigen::Vector3d initial_tool_position =
    kinematics->position(initial_cspace_position, kinematics->frame(tool_frame_name));

std::unique_ptr<cumotion::Obstacle> cuboid =
    cumotion::CreateObstacle(cumotion::Obstacle::Type::CUBOID);
Eigen::Vector3d obstacle_size = Eigen::Vector3d(0.1, 0.1, 0.1) * 2;
cuboid->setAttribute(cumotion::Obstacle::Attribute::SIDE_LENGTHS, obstacle_size);

cumotion::Pose3 obstacle_pose =
    cumotion::Pose3::FromTranslation(initial_tool_position + Eigen::Vector3d(0.25, 0.0, 0.0));
cumotion::World::ObstacleHandle obstacle_handle = world->addObstacle(*cuboid, obstacle_pose);

```

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

### Create Trajectory Optimizer Config from File

Source: https://nvidia-isaac.github.io/cumotion/api/cpp_api.html

Loads trajectory optimizer configuration parameters from a specified YAML file. Ensures the file path, YAML content, robot description, and tool frame name are valid. Returns nullptr and logs an error on failure.

```cpp
std::unique_ptr<TrajectoryOptimizerConfig> cumotion::CreateTrajectoryOptimizerConfigFromFile(
    _const std::filesystem::path &trajectory_optimizer_config_file_,
    _const RobotDescription &robot_description_,
    _const std::string &tool_frame_name_,
    _const WorldViewHandle &world_view_ );
```

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

### Install cuMotion Python Wheel on Windows

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Installs the cuMotion Python wheel file using PowerShell. Replace 'cp312' with the appropriate Python tag for your version.

```powershell
pip install (Get-Item python_wheels/cumotion-*-cp312-*.whl)

```

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

### Load Robot Description and Initialize Kinematics (Python)

Source: https://nvidia-isaac.github.io/cumotion/tutorials/kinematics_tutorial.html

Loads a robot description from specified file paths and initializes the kinematics object. It is recommended to call this function once and reuse the kinematics instance.

```python
robot_description: cumotion.RobotDescription = cumotion.load_robot_from_file(xrdf_path, urdf_path)
kinematics: cumotion.Kinematics = robot_description.kinematics()

```

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

### Install cuMotion Python Wheel on Linux

Source: https://nvidia-isaac.github.io/cumotion/getting_started.html

Installs the cuMotion Python wheel file. Replace 'cp312' with the appropriate Python tag for your version (e.g., 'cp311' for Python 3.11).

```bash
pip install python_wheels/cumotion-*-cp312-*.whl

```

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

### DepthImage stride() Method

Source: https://nvidia-isaac.github.io/cumotion/api/cpp_api.html

Returns the number of elements between the start of one row and the start of the next row in the depth data buffer. This value is always greater than or equal to the image width.

```cpp
virtual int stride() const override
```

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

### create_motion_planner_config_from_file

Source: https://nvidia-isaac.github.io/cumotion/api/python_api.html

Creates motion planner configuration from a file.

```APIDOC
## create_motion_planner_config_from_file

### Description
Creates motion planner configuration from a file.

### Method
`create_motion_planner_config_from_file(filepath)`
```

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

### Load Robot Description and Initialize Kinematics (C++)

Source: https://nvidia-isaac.github.io/cumotion/tutorials/kinematics_tutorial.html

Loads a robot description from specified files and initializes the kinematics object. It is recommended to call this function once and reuse the kinematics instance.

```cpp
std::unique_ptr<cumotion::RobotDescription> robot_description = 
    cumotion::LoadRobotFromFile(xrdf_file, urdf_file);
std::unique_ptr<cumotion::Kinematics> kinematics = robot_description->kinematics();

```

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

### Get Quaternion Y Component

Source: https://nvidia-isaac.github.io/cumotion/api/cpp_api.html

Retrieve the 'y' component of the quaternion representation.

```cpp
inline double y() const#
```

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

### Get Obstacle Type

Source: https://nvidia-isaac.github.io/cumotion/api/cpp_api.html

Retrieves the geometric primitive type of the obstacle.

```cpp
virtual Type type() const = 0#  

    
Return the `Obstacle::Type` of this obstacle.  
```

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

### Create Default IK Solver Configuration

Source: https://nvidia-isaac.github.io/cumotion/tutorials/inverse_kinematics_tutorial.html

Use this function to create a default configuration for the IK solver. It requires the robot description, the name of the tool frame, and a world view for collision checking.

```cpp
std::unique_ptr<cumotion::CollisionFreeIkSolverConfig> config =
    cumotion::CreateDefaultCollisionFreeIkSolverConfig(
        *robot_description, tool_frame_name, world_view);

```

```python
config = cumotion.create_default_collision_free_ik_solver_config(
    robot_description, tool_frame_name, world_view
)

```

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

### Load Robot Description and Initialize World

Source: https://nvidia-isaac.github.io/cumotion/tutorials/trajectory_optimization_tutorial.html

Loads the UR10 robot description and sets up the simulation world with an obstacle. This is a prerequisite for trajectory optimization.

```python
robot_description: cumotion.RobotDescription = cumotion.load_robot_from_file(
    xrdf_path, urdf_path)

# Get the tool frame name and default c-space position.
tool_frame_name = robot_description.tool_frame_names()[0]
initial_cspace_position = robot_description.default_cspace_configuration()

# Create a world and add a world view.
world: cumotion.World = cumotion.create_world()
world_view: cumotion.WorldView = world.add_world_view()

# Create a cuboid obstacle near the end effector.
kinematics: cumotion.Kinematics = robot_description.kinematics()
initial_tool_position = kinematics.position(initial_cspace_position, tool_frame_name)

cuboid: cumotion.Obstacle = cumotion.create_obstacle(cumotion.Obstacle.Type.CUBOID)
obstacle_size = np.array([0.1, 0.1, 0.1]) * 2
cuboid.set_attribute(cumotion.Obstacle.Attribute.SIDE_LENGTHS, obstacle_size)

obstacle_pose = cumotion.Pose3.from_translation(
    initial_tool_position + np.array([0.25, 0.0, 0.0]))
obstacle_handle: cumotion.World.ObstacleHandle = world.add_obstacle(cuboid, obstacle_pose)
```

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

### Get Inverse Rotation

Source: https://nvidia-isaac.github.io/cumotion/api/cpp_api.html

Compute and return the inverse of the current rotation.

```cpp
Rotation3 inverse() const#
```

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

### Get Matrix Representation

Source: https://nvidia-isaac.github.io/cumotion/api/cpp_api.html

Retrieve the 3x3 matrix representation of the rotation.

```cpp
Eigen::Matrix3d matrix() const#
```

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

### Get Quaternion Representation

Source: https://nvidia-isaac.github.io/cumotion/api/cpp_api.html

Retrieve the normalized quaternion representation of the rotation.

```cpp
inline Eigen::Quaterniond quaternion() const#
```

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

### C-Space Target RMP Configuration Example

Source: https://nvidia-isaac.github.io/cumotion/concepts/rmpflow.html

This YAML snippet shows the configuration for the C-Space Target RMP. It includes parameters for the metric scalar, position gain, damping gain, robust position term threshold, and additional inertia.

```yaml
c_space_target_rmp:
  metric_scalar: 1.0
  position_gain: 100.0
  damping_gain: 10.0
  robust_position_term_thresh: 0.1
  inertia: 0.0
```

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

### Load Robot Description From File (C++)

Source: https://nvidia-isaac.github.io/cumotion/tutorials/robot_description_tutorial.html

Reads XRDF file contents into a stringstream for loading.

```cpp
std::ifstream xrdf_fstream(xrdf_file);
std::stringstream xrdf_ss;
xrdf_ss << xrdf_fstream.rdbuf();

```

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

### Get Quaternion Z Component

Source: https://nvidia-isaac.github.io/cumotion/api/cpp_api.html

Retrieve the 'z' component of the quaternion representation.

```cpp
inline double z() const#
```

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

### Get Quaternion X Component

Source: https://nvidia-isaac.github.io/cumotion/api/cpp_api.html

Retrieve the 'x' component of the quaternion representation.

```cpp
inline double x() const#
```

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

### Create RmpFlowConfig from Memory

Source: https://nvidia-isaac.github.io/cumotion/api/cpp_api.html

Load RMPflow parameters from a string. Requires robot description and world view.

```cpp
std::unique_ptr<RmpFlowConfig> cumotion::CreateRmpFlowConfigFromMemory(
    _const std::string &rmpflow_config_,
    _const RobotDescription &robot_description_,
    _const WorldViewHandle &world_view_ );

```

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

### Get Quaternion W Component

Source: https://nvidia-isaac.github.io/cumotion/api/cpp_api.html

Retrieve the 'w' component of the quaternion representation.

```cpp
inline double w() const#
```

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

### Include Collision-Free IK Solver Header

Source: https://nvidia-isaac.github.io/cumotion/api/cpp_api.html

Include the necessary header file for the collision-free IK solver.

```cpp
#include <cumotion/collision_free_ik_solver.h>
```

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

### Get C-Space Coordinate Names (Python)

Source: https://nvidia-isaac.github.io/cumotion/tutorials/robot_description_tutorial.html

Retrieves and prints the names of each configuration space coordinate.

```python
coord_names = [robot_description.cspace_coord_name(coord_index) for coord_index in
               range(num_coords)]
for (index, name) in enumerate(coord_names):
    print("Coordinate {} name: {}".format(index, name))

```

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

### create_default_motion_planner_config

Source: https://nvidia-isaac.github.io/cumotion/api/python_api.html

Creates a default motion planner configuration.

```APIDOC
## create_default_motion_planner_config

### Description
Creates a default motion planner configuration.

### Method
`create_default_motion_planner_config()`
```

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

### Get C-Space Coordinate Names (C++)

Source: https://nvidia-isaac.github.io/cumotion/tutorials/robot_description_tutorial.html

Retrieves and prints the names of each configuration space coordinate.

```cpp
std::vector<std::string> coord_names(num_coords);
for (int coord_index = 0; coord_index < num_coords; ++coord_index) {
coord_names[coord_index] = robot_description->cSpaceCoordName(coord_index);
}
for (int coord_index = 0; coord_index < num_coords; ++coord_index) {
std::cout << "Coordinate " << coord_index << " name: " << coord_names[coord_index] << "\n";
}

```

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

### Get C-Space Coordinate Names

Source: https://nvidia-isaac.github.io/cumotion/tutorials/kinematics_tutorial.html

Query the descriptive names for each c-space coordinate. Useful for debugging and analysis.

```C++
const int num_coords = kinematics->numCSpaceCoords();
std::vector<std::string> coord_names(num_coords);
for (int coord_index = 0; coord_index < num_coords; ++coord_index) {
  coord_names[coord_index] = robot_description->cSpaceCoordName(coord_index);
}
std::cout << "Number of c-space coordinates: " << num_coords << "\n";
for (int coord_index = 0; coord_index < num_coords; ++coord_index) {
  std::cout << "Coordinate " << coord_index << " name: " << coord_names[coord_index] << "\n";
}
```

```Python
num_coords = kinematics.num_cspace_coords()
print("Number of c-space coordinates:", num_coords)
for coord_index in range(num_coords):
    coord_name = kinematics.cspace_coord_name(coord_index)
    print("Coordinate {} name: {}".format(coord_index, coord_name))
```

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

### create_motion_planner

Source: https://nvidia-isaac.github.io/cumotion/api/python_api.html

Create a MotionPlanner with the given config.

```APIDOC
cumotion.create_motion_planner( 
    _config : cumotion.cumotion.MotionPlannerConfig_, ) → cumotion.cumotion.MotionPlanner#     
Create a MotionPlanner with the given config.
```

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

### Create Trajectory Optimizer Instance (Python)

Source: https://nvidia-isaac.github.io/cumotion/tutorials/trajectory_optimization_tutorial.html

Creates an instance of the trajectory optimizer in Python, ready for use after configuration.

```python
optimizer: cumotion.TrajectoryOptimizer = cumotion.create_trajectory_optimizer(config)
```

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

### Get Number of C-Space Coordinates (Python)

Source: https://nvidia-isaac.github.io/cumotion/tutorials/robot_description_tutorial.html

Retrieves the total number of configuration space coordinates for the robot.

```python
num_coords = robot_description.num_cspace_coords()

```

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

### Load Robot Description From Memory (C++)

Source: https://nvidia-isaac.github.io/cumotion/tutorials/robot_description_tutorial.html

Loads a robot description from string contents of XRDF and URDF files.

```cpp
std::ifstream xrdf_fstream(xrdf_file);
std::stringstream xrdf_ss;
xrdf_ss << xrdf_fstream.rdbuf();
const std::string xrdf_contents = xrdf_ss.str();

std::ifstream urdf_fstream(urdf_file);
std::stringstream urdf_ss;
urdf_ss << urdf_fstream.rdbuf();
const std::string urdf_contents = urdf_ss.str();

std::unique_ptr<cumotion::RobotDescription> robot_description_from_memory =
    cumotion::LoadRobotFromMemory(xrdf_contents, urdf_contents);

```

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

### Get Number of C-Space Coordinates (C++)

Source: https://nvidia-isaac.github.io/cumotion/tutorials/robot_description_tutorial.html

Retrieves the total number of configuration space coordinates for the robot.

```cpp
const int num_coords = robot_description->numCSpaceCoords();

```
Tokens:
Raw