Struct RobotSetConfigurationModule

pub struct RobotSetConfigurationModule { /* private fields */ }

The robot set analogue of the RobotConfigurationModule. Multiple robot configurations can be added and configured in the set of robots here, then can be saved to a file for loading at a later time. This is a relatively simple wrapper around multiple RobotConfigurationModule objects that will be used to initialize many other robot set modules.

Example

use optima::robot_modules::robot_configuration_module::{ContiguousChainMobilityMode, RobotConfigurationModule};
use optima::robot_set_modules::robot_set_configuration_module::RobotSetConfigurationModule;
use optima::utils::utils_robot::robot_module_utils::RobotNames;
use optima::utils::utils_se3::optima_se3_pose::{OptimaSE3Pose, OptimaSE3PoseType};

let mut r = RobotSetConfigurationModule::new_empty();

r.add_robot_configuration_from_names(RobotNames::new_base("ur5")).expect("error");
let mut sawyer_configuration = RobotConfigurationModule::new_from_names(RobotNames::new_base("sawyer")).expect("error");
sawyer_configuration.set_mobile_base(ContiguousChainMobilityMode::PlanarTranslation {x_bounds: (-2.0, 2.0),y_bounds: (-2.0, 2.0)});
sawyer_configuration.set_base_offset(&OptimaSE3Pose::new_from_euler_angles(0.,0.,0.,1.0,0.,0., &OptimaSE3PoseType::ImplicitDualQuaternion)).expect("error");
r.add_robot_configuration(sawyer_configuration).expect("error");

r.save_robot_set_configuration_module("test_set").expect("error");

Implementations

impl RobotSetConfigurationModule

pub fn new_empty() -> Self

Examples found in repository

examples/3_robot_set_configurations.rs (line 11)

fn main() {
    // Initialize `RobotSetConfigurationModule`
    let mut robot_set_configuration_module = RobotSetConfigurationModule::new_empty();

    // Load a base robot configuration module
    let mut ur5_configuration = RobotConfigurationModule::new_from_names(RobotNames::new_base("ur5")).expect("error");
    // Set the ur5 to have a planar translation mobile base.
    ur5_configuration.set_mobile_base(ContiguousChainMobilityMode::PlanarTranslation {
        x_bounds: (-2.0, 2.0),
        y_bounds: (-2.0, 2.0)
    }).expect("error");

    // Add the ur5 configuration to the robot_set_configuration
    robot_set_configuration_module.add_robot_configuration(ur5_configuration).expect("error");

    let mut sawyer_configuration = RobotConfigurationModule::new_from_names(RobotNames::new_base("sawyer")).expect("error");
    // Move the sawyer robot over 1 meter on the y axis so it is not overlapping with the ur5 robot.
    sawyer_configuration.set_base_offset(&OptimaSE3Pose::new_from_euler_angles(0.,0.,0., 0., 1., 0., &OptimaSE3PoseType::ImplicitDualQuaternion)).expect("error");
    // Remove the pedestal from the sawyer model.
    sawyer_configuration.set_dead_end_link(2).expect("error");

    // Add the sawyer configuration to the robot_set_configuration
    robot_set_configuration_module.add_robot_configuration(sawyer_configuration).expect("error");

    // Similar to a `RobotConfigurationModule`, a `RobotSetConfigurationModule` can be saved to a file
    // to allow for easy loading of a model at a later time.  This command will save a file
    // `optima_toolbox/optima_assets/optima_robot_sets/test_configuration.JSON`
    robot_set_configuration_module.save_robot_set_configuration_module("test_configuration").expect("error");

    // We will now load the just saved configuration
    let loaded_robot_set_configuration_module = RobotSetConfigurationModule::new_from_set_name("test_configuration").expect("error");

    // This loaded robot set configuration will now be used to initialize a `RobotSet`.
    let robot_set = RobotSet::new_from_robot_set_configuration_module(loaded_robot_set_configuration_module);

    // When we now print information about the robot set, the changes we made to the configurations
    // are reflected in the combined model.
    robot_set.print_summary();
    robot_set.robot_set_configuration_module().print_summary();
    robot_set.robot_set_joint_state_module().print_dof_summary();
}

pub fn new_from_set_name(set_name: &str) -> Result<Self, OptimaError>

Examples found in repository

examples/3_robot_set_configurations.rs (line 39)

fn main() {
    // Initialize `RobotSetConfigurationModule`
    let mut robot_set_configuration_module = RobotSetConfigurationModule::new_empty();

    // Load a base robot configuration module
    let mut ur5_configuration = RobotConfigurationModule::new_from_names(RobotNames::new_base("ur5")).expect("error");
    // Set the ur5 to have a planar translation mobile base.
    ur5_configuration.set_mobile_base(ContiguousChainMobilityMode::PlanarTranslation {
        x_bounds: (-2.0, 2.0),
        y_bounds: (-2.0, 2.0)
    }).expect("error");

    // Add the ur5 configuration to the robot_set_configuration
    robot_set_configuration_module.add_robot_configuration(ur5_configuration).expect("error");

    let mut sawyer_configuration = RobotConfigurationModule::new_from_names(RobotNames::new_base("sawyer")).expect("error");
    // Move the sawyer robot over 1 meter on the y axis so it is not overlapping with the ur5 robot.
    sawyer_configuration.set_base_offset(&OptimaSE3Pose::new_from_euler_angles(0.,0.,0., 0., 1., 0., &OptimaSE3PoseType::ImplicitDualQuaternion)).expect("error");
    // Remove the pedestal from the sawyer model.
    sawyer_configuration.set_dead_end_link(2).expect("error");

    // Add the sawyer configuration to the robot_set_configuration
    robot_set_configuration_module.add_robot_configuration(sawyer_configuration).expect("error");

    // Similar to a `RobotConfigurationModule`, a `RobotSetConfigurationModule` can be saved to a file
    // to allow for easy loading of a model at a later time.  This command will save a file
    // `optima_toolbox/optima_assets/optima_robot_sets/test_configuration.JSON`
    robot_set_configuration_module.save_robot_set_configuration_module("test_configuration").expect("error");

    // We will now load the just saved configuration
    let loaded_robot_set_configuration_module = RobotSetConfigurationModule::new_from_set_name("test_configuration").expect("error");

    // This loaded robot set configuration will now be used to initialize a `RobotSet`.
    let robot_set = RobotSet::new_from_robot_set_configuration_module(loaded_robot_set_configuration_module);

    // When we now print information about the robot set, the changes we made to the configurations
    // are reflected in the combined model.
    robot_set.print_summary();
    robot_set.robot_set_configuration_module().print_summary();
    robot_set.robot_set_joint_state_module().print_dof_summary();
}

pub fn add_robot_configuration_from_names( &mut self, robot_names: RobotNames<'_>, ) -> Result<(), OptimaError>

pub fn add_robot_configuration( &mut self, robot_configuration: RobotConfigurationModule, ) -> Result<(), OptimaError>

Examples found in repository

examples/3_robot_set_configurations.rs (line 22)

fn main() {
    // Initialize `RobotSetConfigurationModule`
    let mut robot_set_configuration_module = RobotSetConfigurationModule::new_empty();

    // Load a base robot configuration module
    let mut ur5_configuration = RobotConfigurationModule::new_from_names(RobotNames::new_base("ur5")).expect("error");
    // Set the ur5 to have a planar translation mobile base.
    ur5_configuration.set_mobile_base(ContiguousChainMobilityMode::PlanarTranslation {
        x_bounds: (-2.0, 2.0),
        y_bounds: (-2.0, 2.0)
    }).expect("error");

    // Add the ur5 configuration to the robot_set_configuration
    robot_set_configuration_module.add_robot_configuration(ur5_configuration).expect("error");

    let mut sawyer_configuration = RobotConfigurationModule::new_from_names(RobotNames::new_base("sawyer")).expect("error");
    // Move the sawyer robot over 1 meter on the y axis so it is not overlapping with the ur5 robot.
    sawyer_configuration.set_base_offset(&OptimaSE3Pose::new_from_euler_angles(0.,0.,0., 0., 1., 0., &OptimaSE3PoseType::ImplicitDualQuaternion)).expect("error");
    // Remove the pedestal from the sawyer model.
    sawyer_configuration.set_dead_end_link(2).expect("error");

    // Add the sawyer configuration to the robot_set_configuration
    robot_set_configuration_module.add_robot_configuration(sawyer_configuration).expect("error");

    // Similar to a `RobotConfigurationModule`, a `RobotSetConfigurationModule` can be saved to a file
    // to allow for easy loading of a model at a later time.  This command will save a file
    // `optima_toolbox/optima_assets/optima_robot_sets/test_configuration.JSON`
    robot_set_configuration_module.save_robot_set_configuration_module("test_configuration").expect("error");

    // We will now load the just saved configuration
    let loaded_robot_set_configuration_module = RobotSetConfigurationModule::new_from_set_name("test_configuration").expect("error");

    // This loaded robot set configuration will now be used to initialize a `RobotSet`.
    let robot_set = RobotSet::new_from_robot_set_configuration_module(loaded_robot_set_configuration_module);

    // When we now print information about the robot set, the changes we made to the configurations
    // are reflected in the combined model.
    robot_set.print_summary();
    robot_set.robot_set_configuration_module().print_summary();
    robot_set.robot_set_joint_state_module().print_dof_summary();
}

pub fn robot_configuration_modules(&self) -> &Vec<RobotConfigurationModule>

pub fn robot_configuration_module( &self, idx: usize, ) -> Result<&RobotConfigurationModule, OptimaError>

pub fn print_summary(&self)

Examples found in repository

examples/2_robot_sets.rs (line 11)

fn main() {
    // Loads a robot set with two robots (a ur5 and sawyer).
    let robot_set = RobotSet::new_from_robot_names(vec![RobotNames::new("ur5", None), RobotNames::new("sawyer", None)]);

    // prints a summary of the robot set configuration
    robot_set.robot_set_configuration_module().print_summary();

    // prints a summary of the robot set's degrees of freedom.
    robot_set.robot_set_joint_state_module().print_dof_summary();
}

examples/3_robot_set_configurations.rs (line 47)

fn main() {
    // Initialize `RobotSetConfigurationModule`
    let mut robot_set_configuration_module = RobotSetConfigurationModule::new_empty();

    // Load a base robot configuration module
    let mut ur5_configuration = RobotConfigurationModule::new_from_names(RobotNames::new_base("ur5")).expect("error");
    // Set the ur5 to have a planar translation mobile base.
    ur5_configuration.set_mobile_base(ContiguousChainMobilityMode::PlanarTranslation {
        x_bounds: (-2.0, 2.0),
        y_bounds: (-2.0, 2.0)
    }).expect("error");

    // Add the ur5 configuration to the robot_set_configuration
    robot_set_configuration_module.add_robot_configuration(ur5_configuration).expect("error");

    let mut sawyer_configuration = RobotConfigurationModule::new_from_names(RobotNames::new_base("sawyer")).expect("error");
    // Move the sawyer robot over 1 meter on the y axis so it is not overlapping with the ur5 robot.
    sawyer_configuration.set_base_offset(&OptimaSE3Pose::new_from_euler_angles(0.,0.,0., 0., 1., 0., &OptimaSE3PoseType::ImplicitDualQuaternion)).expect("error");
    // Remove the pedestal from the sawyer model.
    sawyer_configuration.set_dead_end_link(2).expect("error");

    // Add the sawyer configuration to the robot_set_configuration
    robot_set_configuration_module.add_robot_configuration(sawyer_configuration).expect("error");

    // Similar to a `RobotConfigurationModule`, a `RobotSetConfigurationModule` can be saved to a file
    // to allow for easy loading of a model at a later time.  This command will save a file
    // `optima_toolbox/optima_assets/optima_robot_sets/test_configuration.JSON`
    robot_set_configuration_module.save_robot_set_configuration_module("test_configuration").expect("error");

    // We will now load the just saved configuration
    let loaded_robot_set_configuration_module = RobotSetConfigurationModule::new_from_set_name("test_configuration").expect("error");

    // This loaded robot set configuration will now be used to initialize a `RobotSet`.
    let robot_set = RobotSet::new_from_robot_set_configuration_module(loaded_robot_set_configuration_module);

    // When we now print information about the robot set, the changes we made to the configurations
    // are reflected in the combined model.
    robot_set.print_summary();
    robot_set.robot_set_configuration_module().print_summary();
    robot_set.robot_set_joint_state_module().print_dof_summary();
}

pub fn save_robot_set_configuration_module( &self, set_name: &str, ) -> Result<(), OptimaError>

Robot set configurations are saved to the optima_assets/optima_robot_sets directory.

Examples found in repository

examples/3_robot_set_configurations.rs (line 36)

fn main() {
    // Initialize `RobotSetConfigurationModule`
    let mut robot_set_configuration_module = RobotSetConfigurationModule::new_empty();

    // Load a base robot configuration module
    let mut ur5_configuration = RobotConfigurationModule::new_from_names(RobotNames::new_base("ur5")).expect("error");
    // Set the ur5 to have a planar translation mobile base.
    ur5_configuration.set_mobile_base(ContiguousChainMobilityMode::PlanarTranslation {
        x_bounds: (-2.0, 2.0),
        y_bounds: (-2.0, 2.0)
    }).expect("error");

    // Add the ur5 configuration to the robot_set_configuration
    robot_set_configuration_module.add_robot_configuration(ur5_configuration).expect("error");

    let mut sawyer_configuration = RobotConfigurationModule::new_from_names(RobotNames::new_base("sawyer")).expect("error");
    // Move the sawyer robot over 1 meter on the y axis so it is not overlapping with the ur5 robot.
    sawyer_configuration.set_base_offset(&OptimaSE3Pose::new_from_euler_angles(0.,0.,0., 0., 1., 0., &OptimaSE3PoseType::ImplicitDualQuaternion)).expect("error");
    // Remove the pedestal from the sawyer model.
    sawyer_configuration.set_dead_end_link(2).expect("error");

    // Add the sawyer configuration to the robot_set_configuration
    robot_set_configuration_module.add_robot_configuration(sawyer_configuration).expect("error");

    // Similar to a `RobotConfigurationModule`, a `RobotSetConfigurationModule` can be saved to a file
    // to allow for easy loading of a model at a later time.  This command will save a file
    // `optima_toolbox/optima_assets/optima_robot_sets/test_configuration.JSON`
    robot_set_configuration_module.save_robot_set_configuration_module("test_configuration").expect("error");

    // We will now load the just saved configuration
    let loaded_robot_set_configuration_module = RobotSetConfigurationModule::new_from_set_name("test_configuration").expect("error");

    // This loaded robot set configuration will now be used to initialize a `RobotSet`.
    let robot_set = RobotSet::new_from_robot_set_configuration_module(loaded_robot_set_configuration_module);

    // When we now print information about the robot set, the changes we made to the configurations
    // are reflected in the combined model.
    robot_set.print_summary();
    robot_set.robot_set_configuration_module().print_summary();
    robot_set.robot_set_joint_state_module().print_dof_summary();
}

impl RobotSetConfigurationModule

pub fn new_empty_py() -> Self

pub fn new_from_set_name_py(set_name: &str) -> Self

pub fn add_robot_configuration_from_names_py( &mut self, robot_name: &str, configuration_name: Option<&str>, )

pub fn add_robot_configuration_py( &mut self, robot_configuration: RobotConfigurationModulePy, )

pub fn save_robot_set_configuration_module_py(&self, set_name: &str)

pub fn num_robot_configurations(&self) -> usize

pub fn robot_configuration_modules_py( &self, py: Python<'_>, ) -> Vec<RobotConfigurationModulePy>

Trait Implementations

impl Clone for RobotSetConfigurationModule

fn clone(&self) -> RobotSetConfigurationModule

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RobotSetConfigurationModule

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RobotSetConfigurationModule

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl IntoPy<Py<PyAny>> for RobotSetConfigurationModule

fn into_py(self, py: Python<'_>) -> PyObject

Performs the conversion.

impl PyClass for RobotSetConfigurationModule

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

impl PyClassImpl for RobotSetConfigurationModule

const DOC: &'static str = "The robot set analogue of the `RobotConfigurationModule`. Multiple robot configurations\ncan be added and configured in the set of robots here, then can be saved to a file for loading\nat a later time. This is a relatively simple wrapper around multiple `RobotConfigurationModule`\nobjects that will be used to initialize many other robot set modules.\n\n# Example\n```text\nuse optima::robot_modules::robot_configuration_module::{ContiguousChainMobilityMode, RobotConfigurationModule};\nuse optima::robot_set_modules::robot_set_configuration_module::RobotSetConfigurationModule;\nuse optima::utils::utils_robot::robot_module_utils::RobotNames;\nuse optima::utils::utils_se3::optima_se3_pose::{OptimaSE3Pose, OptimaSE3PoseType};\n\nlet mut r = RobotSetConfigurationModule::new_empty();\n\nr.add_robot_configuration_from_names(RobotNames::new_base(\"ur5\")).expect(\"error\");\nlet mut sawyer_configuration = RobotConfigurationModule::new_from_names(RobotNames::new_base(\"sawyer\")).expect(\"error\");\nsawyer_configuration.set_mobile_base(ContiguousChainMobilityMode::PlanarTranslation {x_bounds: (-2.0, 2.0),y_bounds: (-2.0, 2.0)});\nsawyer_configuration.set_base_offset(&OptimaSE3Pose::new_from_euler_angles(0.,0.,0.,1.0,0.,0., &OptimaSE3PoseType::ImplicitDualQuaternion)).expect(\"error\");\nr.add_robot_configuration(sawyer_configuration).expect(\"error\");\n\nr.save_robot_set_configuration_module(\"test_set\").expect(\"error\");\n```\u{0}"

Class doc string

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

type Layout = PyCell<RobotSetConfigurationModule>

Layout

type BaseType = PyAny

Base class

type ThreadChecker = ThreadCheckerStub<RobotSetConfigurationModule>

This handles following two situations:

fn for_all_items(visitor: &mut dyn FnMut(&PyClassItems))

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyMethods<RobotSetConfigurationModule> for PyClassImplCollector<RobotSetConfigurationModule>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for RobotSetConfigurationModule

const NAME: &'static str = "RobotSetConfigurationModule"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.

type AsRefTarget = PyCell<RobotSetConfigurationModule>

Utility type to make Py::as_ref work.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

PyTypeObject instance for this type.

fn is_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type.

impl SaveAndLoadable for RobotSetConfigurationModule

type SaveType = Vec<String>

fn get_save_serialization_object(&self) -> Self::SaveType

fn load_from_json_string(json_str: &str) -> Result<Self, OptimaError>

where Self: Sized,

fn get_serialization_string(&self) -> String

fn save_to_path(&self, path: &OptimaStemCellPath) -> Result<(), OptimaError>

fn load_from_path(path: &OptimaStemCellPath) -> Result<Self, OptimaError>

where Self: Sized,

impl Serialize for RobotSetConfigurationModule

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.