Repo symbol

reach_ros repository

reach_ros

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

Repo symbol

reach_ros repository

reach_ros

ROS Distro
jazzy

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released UNRELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

Repo symbol

reach_ros repository

reach_ros

ROS Distro
kilted

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released UNRELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

Repo symbol

reach_ros repository

reach_ros

ROS Distro
rolling

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released UNRELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

No version for distro ardent showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

reach_ros repository

reach_ros

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

No version for distro bouncy showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

reach_ros repository

reach_ros

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

No version for distro crystal showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

reach_ros repository

reach_ros

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

No version for distro eloquent showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

reach_ros repository

reach_ros

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

No version for distro dashing showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

reach_ros repository

reach_ros

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

No version for distro galactic showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

reach_ros repository

reach_ros

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

No version for distro foxy showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

reach_ros repository

reach_ros

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

No version for distro iron showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

reach_ros repository

reach_ros

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

No version for distro lunar showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

reach_ros repository

reach_ros

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

No version for distro jade showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

reach_ros repository

reach_ros

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

No version for distro indigo showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

reach_ros repository

reach_ros

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

No version for distro hydro showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

reach_ros repository

reach_ros

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

No version for distro kinetic showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

reach_ros repository

reach_ros

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

No version for distro melodic showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

reach_ros repository

reach_ros

ROS Distro
humble

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros2.git
VCS Type git
VCS Version master
Last Updated 2025-07-09
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.4.0

README

REACH ROS Plugins

Ubuntu

This package contains the ROS2-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a colcon workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros2.git
cd ..

Install the dependencies

vcs import src < src/reach_ros2/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

colcon build --symlink-install

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to launch the demo from ROS 2 and see the Python instructions to see how you can use the Python interface to launch studies.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create any files describing your robot system required by the REACH plugins (e.g., URDF, SRDF, kinematics file, joint limits file, etc.)
  2. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  3. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    ros2 launch reach_ros setup.launch robot_description_file:=<path_to_URDF>
    
  1. Run the reach study analysis
    ros2 launch reach_ros start.launch \
      robot_description_file:=<path_to_URDF> \
      robot_description_semantic_file:=<path_to_SRDF> \
      robot_description_kinematics_file:=<path_to_kinematics.yaml> \
      robot_description_joint_limits_file:=<path_to_joint_limits.yaml> \
      config_file:=<config_file.yaml> \
      config_name:=<arbitrary_config> \
      results_dir:=<arbitrary_results_directory>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]

File truncated at 100 lines see the full file

Repo symbol

reach_ros repository

reach_ros

ROS Distro
noetic

Repository Summary

Checkout URI https://github.com/ros-industrial/reach_ros.git
VCS Type git
VCS Version master
Last Updated 2024-06-15
Dev Status DEVELOPED
Released RELEASED
Tags No category tags.
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

Packages

Name Version
reach_ros 1.1.4

README

REACH ROS Plugins

Focal Noetic

This package contains the ROS1-based plugin implemenations of REACH kinematics, evaluation, and display interfaces

REACH ROS

Installation

First, clone the repository into a catkin workspace

cd ~/reach_ws/src
git clone https://github.com/ros-industrial/reach_ros.git
cd ..

Install the dependencies

vcs import src < src/reach_ros/dependencies.repos
rosdep install --from-paths src --ignore-src -r -y

Build the repository

catkin build

Demo

A simple demonstration of the capability of this repository is provided in the demo sub-directory. See the instructions for details on how to run the demo.

Usage

Use the following steps to run a reach study with a robot using the ROS1 infrastructure and plugins.

  1. Create a URDF of your robot system
  2. Create a launch file to load the URDF, SRDF, and other required parameters (e.g. related to kinematics, joint, limits) to the parameter server (see this demo example file)
  3. Create a mesh model of the workpiece

    Note: the origin of this model should align with the kinematic base frame of the robot

  4. Create a point cloud of the target points on the workpiece
    • This point cloud can be generated using a command line tool from PCL 1.8:
      pcl_mesh_sampling <workpiece_mesh>.ply <output_cloud>.pcd -n_samples <number of samples> -leaf_size <leaf_size> -write_normals true
      
  1. Create a configuration YAML file defining the parameters of the reach study and the configuration of the interface plugins (see this demo example)
  2. Run the setup launch file
    roslaunch reach_ros setup.launch robot:=<load_robot_parameters>.launch
    
  1. Run the reach study analysis
    roslaunch reach_ros start.launch config_file:=<config_file.yaml> config_name:=<arbitrary_config>
    

Evaluation Plugins

Manipulability

This plugin uses MoveIt! to calculate the manipulability of a robot pose. Higher manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Manipulability Scaled

This plugin uses MoveIt! to calculate the manipulability of a robot pose divided by the characteristic length of the motion group. The characteristic length is computed by walking from the base link to the tip link of the motion group and summing the distances between adjacent links. Higher scaled manipulability results in a higher pose score. Range: [0, inf)

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only
  • excluded_links (optional)
    • The names of links contained in the motion group that should not contribute to the characteristic length

Manipulability Ratio

This plugin uses MoveIt! to calculate the manipulability of a robot pose and evaluate a score. The score is calculated as the ratio of the smallest manipulability value to the largest manipulability value. The larger this ratio, the more uniform the dexterity and the higher the score. Range [0, 1]

Parameters:

  • planning_group
    • The name of the planning group with which to evaluate the manipulability of a given robot pose
  • jacobian_row_subset (optional)
    • The indices of the rows of the Jacobian to use when evaluating the manipulability. The row indices should be on [0, 6) and correspond to the output space [x, y, z, rx, ry, rz]
    • Ex. jacobian_row_subset: [0, 1, 2] # position manipulability only

Distance Penalty

This plugin uses the MoveIt! collision environment to calculate the distance to closest collision for a robot pose. That distance value is then used to score the robot pose. Larger distance to closest collision

File truncated at 100 lines see the full file