openravepy_int Module¶
- class openravepy.openravepy_int.AABB¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
__init__( (object)arg1, (object)pos, (object)extents) -> None
- extents((AABB)arg1) → object¶
- pos((AABB)arg1) → object¶
- class openravepy.openravepy_int.CloningOptions¶
Bases: Boost.Python.enum
CloningOptions
- Bodies = openravepy.openravepy_int.CloningOptions.Bodies¶
- RealControllers = openravepy.openravepy_int.CloningOptions.RealControllers¶
- Sensors = openravepy.openravepy_int.CloningOptions.Sensors¶
- Simulation = openravepy.openravepy_int.CloningOptions.Simulation¶
- Viewer = openravepy.openravepy_int.CloningOptions.Viewer¶
- names = {'Viewer': openravepy.openravepy_int.CloningOptions.Viewer, 'RealControllers': openravepy.openravepy_int.CloningOptions.RealControllers, 'Sensors': openravepy.openravepy_int.CloningOptions.Sensors, 'Bodies': openravepy.openravepy_int.CloningOptions.Bodies, 'Simulation': openravepy.openravepy_int.CloningOptions.Simulation}¶
- values = {8: openravepy.openravepy_int.CloningOptions.RealControllers, 1: openravepy.openravepy_int.CloningOptions.Bodies, 2: openravepy.openravepy_int.CloningOptions.Viewer, 4: openravepy.openravepy_int.CloningOptions.Simulation, 16: openravepy.openravepy_int.CloningOptions.Sensors}¶
- class openravepy.openravepy_int.CollisionAction¶
Bases: Boost.Python.enum
CollisionAction
action to perform whenever a collision is detected between objects- DefaultAction = openravepy.openravepy_int.CollisionAction.DefaultAction¶
- Ignore = openravepy.openravepy_int.CollisionAction.Ignore¶
- names = {'DefaultAction': openravepy.openravepy_int.CollisionAction.DefaultAction, 'Ignore': openravepy.openravepy_int.CollisionAction.Ignore}¶
- values = {0: openravepy.openravepy_int.CollisionAction.DefaultAction, 1: openravepy.openravepy_int.CollisionAction.Ignore}¶
- class openravepy.openravepy_int.CollisionChecker¶
Bases: openravepy.openravepy_int.Interface
Raises an exception This class cannot be instantiated from Python
- CheckCollision((CollisionChecker)arg1, (KinBody)body) → bool¶
CheckCollision( (CollisionChecker)arg1, (KinBody)body, (CollisionReport)report) -> bool
CheckCollision( (CollisionChecker)arg1, (KinBody)body1, (KinBody)body2) -> bool
CheckCollision( (CollisionChecker)arg1, (KinBody)body1, (KinBody)body2, (CollisionReport)report) -> bool
CheckCollision( (CollisionChecker)arg1, (object)link) -> bool
CheckCollision( (CollisionChecker)arg1, (object)link, (CollisionReport)report) -> bool
CheckCollision( (CollisionChecker)arg1, (object)link1, (object)link2) -> bool
CheckCollision( (CollisionChecker)arg1, (object)link1, (object)link2, (CollisionReport)report) -> bool
CheckCollision( (CollisionChecker)arg1, (object)link, (KinBody)body) -> bool
CheckCollision( (CollisionChecker)arg1, (object)link, (KinBody)body, (CollisionReport)report) -> bool
CheckCollision( (CollisionChecker)arg1, (object)link, (object)bodyexcluded, (object)linkexcluded) -> bool
CheckCollision( (CollisionChecker)arg1, (object)link, (object)bodyexcluded, (object)linkexcluded, (CollisionReport)report) -> bool
CheckCollision( (CollisionChecker)arg1, (KinBody)body, (object)bodyexcluded, (object)linkexcluded) -> bool
CheckCollision( (CollisionChecker)arg1, (KinBody)body, (object)bodyexcluded, (object)linkexcluded, (CollisionReport)report) -> bool
CheckCollision( (CollisionChecker)arg1, (Ray)ray, (KinBody)body) -> bool
CheckCollision( (CollisionChecker)arg1, (Ray)ray, (KinBody)body, (CollisionReport)report) -> bool
CheckCollision( (CollisionChecker)arg1, (Ray)ray) -> bool
CheckCollision( (CollisionChecker)arg1, (Ray)arg2, (CollisionReport)ray) -> bool
- CheckCollisionRays((CollisionChecker)arg1, (object)rays, (KinBody)body[, (bool)front_facing_only]) → object :¶
Check if any rays hit the body and returns their contact points along with a vector specifying if a collision occured or not. Rays is a Nx6 array, first 3 columsn are position, last 3 are direction+range.
- DestroyEnvironment((CollisionChecker)arg1) → None¶
- GetCollisionOptions((CollisionChecker)arg1) → int :¶
int GetCollisionOptions()
get the current collision options
- InitEnvironment((CollisionChecker)arg1) → bool¶
- InitKinBody((CollisionChecker)arg1, (KinBody)arg2) → bool¶
- RemoveKinBody((CollisionChecker)arg1, (KinBody)arg2) → None¶
- SetCollisionOptions((CollisionChecker)arg1, (int)arg2) → bool :¶
bool SetCollisionOptions(int collisionoptions)
Set basic collision options using the CollisionOptions enum.
- class openravepy.openravepy_int.CollisionOptions¶
Bases: Boost.Python.enum
CollisionOptions
options for collision checker- ActiveDOFs = openravepy.openravepy_int.CollisionOptions.ActiveDOFs¶
- Contacts = openravepy.openravepy_int.CollisionOptions.Contacts¶
- Distance = openravepy.openravepy_int.CollisionOptions.Distance¶
- RayAnyHit = openravepy.openravepy_int.CollisionOptions.RayAnyHit¶
- UseTolerance = openravepy.openravepy_int.CollisionOptions.UseTolerance¶
- names = {'Distance': openravepy.openravepy_int.CollisionOptions.Distance, 'UseTolerance': openravepy.openravepy_int.CollisionOptions.UseTolerance, 'RayAnyHit': openravepy.openravepy_int.CollisionOptions.RayAnyHit, 'ActiveDOFs': openravepy.openravepy_int.CollisionOptions.ActiveDOFs, 'Contacts': openravepy.openravepy_int.CollisionOptions.Contacts}¶
- values = {8: openravepy.openravepy_int.CollisionOptions.RayAnyHit, 1: openravepy.openravepy_int.CollisionOptions.Distance, 2: openravepy.openravepy_int.CollisionOptions.UseTolerance, 4: openravepy.openravepy_int.CollisionOptions.Contacts, 16: openravepy.openravepy_int.CollisionOptions.ActiveDOFs}¶
- class openravepy.openravepy_int.CollisionReport¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
- contacts¶
- minDistance¶
- numCols¶
- numWithinTol¶
- options¶
- plink1¶
- plink2¶
- class openravepy.openravepy_int.ConfigurationSpecification¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
__init__( (object)arg1, (ConfigurationSpecification)spec) -> None
__init__( (object)arg1, (Group)group) -> None
__init__( (object)arg1, (str)xmldata) -> None
- AddDeltaTimeGroup((ConfigurationSpecification)arg1) → int :¶
int AddDeltaTimeGroup()
adds the deltatime tag to the end if one doesn’t exist and returns the index into the configuration space
- AddDerivativeGroups((ConfigurationSpecification)arg1, (int)arg2, (bool)adddeltatime) → None :¶
void AddDerivativeGroups(int deriv, bool adddeltatime = false )
adds velocity, acceleration, etc groups for every position group.
- Parameters
- deriv -
- The position derivative to add, this must be greater than 0. If 2 is specified, only the acceleration groups of the alread present position groups will be added.
- adddeltatime -
- If true will add the ‘deltatime’ tag, which is necessary for trajectory sampling If the derivative groups already exist, they are checked for and/or modified. Note that the configuration space might be re-ordered as a result of this function call. If a new group is added, its interpolation will be the derivative of the position group as returned by GetInterpolationDerivative.
- AddGroup((ConfigurationSpecification)arg1, (str)name, (int)dof, (str)interpolation) → int :¶
int AddGroup(const std::string & name, int dof, const std::string & interpolation = “” )
Adds a new group to the specification and returns its new offset.
If the new group’s semantic name does not exist in the current specification, adds it and returns the new offset. If the new group’s semantic name exists in the current specification and it exactly matches, then function returns the old group’s index. If the semantic names match, but parameters do not match, then an openrave_exception is thrown. This method is not responsible for merging semantic information
AddGroup( (ConfigurationSpecification)arg1, (Group)group) -> int :
int AddGroup(const Group & g)
Adds a new group to the specification and returns its new offset.
- Parameters
- g -
- the group whose name, dof, and interpolation are extracted. If the new group’s semantic name does not exist in the current specification, adds it and returns the new offset. If the new group’s semantic name exists in the current specification and it exactly matches, then function returns the old group’s index. If the semantic names match, but parameters do not match, then an openrave_exception is thrown. This method is not responsible for merging semantic information
- AddVelocityGroups((ConfigurationSpecification)arg1, (bool)adddeltatime) → None :¶
void AddVelocityGroups(bool adddeltatime)
- ConvertToVelocitySpecification((ConfigurationSpecification)arg1) → ConfigurationSpecification :¶
ConfigurationSpecification ConvertToVelocitySpecification()
converts all the groups to the corresponding velocity groups and returns the specification
The velocity configuration space will have a one-to-one correspondence with the original configuration. The interpolation of each of the groups will correspondingly represent the derivative as returned by GetInterpolationDerivative. Only position specifications will be converted, any other groups will be left untouched.
- ExtractDeltaTime((ConfigurationSpecification)arg1, (object)data) → object :¶
bool ExtractDeltaTime(dReal & deltatime, std::vector< dReal >::const_iterator itdata)
extracts the delta time from the configuration if one exists
- Return
- true if deltatime exists in the current configuration, otherwise false
- ExtractJointValues((ConfigurationSpecification)arg1, (object)data, (KinBody)body, (object)indices[, (int)timederivative]) → object :¶
bool ExtractJointValues(std::vector< dReal >::iterator itvalues, std::vector< dReal >::const_iterator itdata, KinBodyConstPtr pbody, const std::vector< int > & indices, int timederivative = 0 )
extracts a body’s joint values given the start of a configuration space point
- Parameters
- inout] -
- itvalues iterator to vector that holds the default values and will be overwritten with the new values. must be initialized
- itdata -
- data in the format of this configuration specification.
- indices -
- the set of DOF indices of the body to extract and write into itvalues.
- timederivative -
- the time derivative of the data to extract Looks for ‘joint_X’ groups. If pbody is not initialized, will choose the first joint_X found.
- Return
- true if at least one group was found for extracting
- ExtractTransform((ConfigurationSpecification)arg1, (object)transform, (object)data, (KinBody)body[, (int)timederivative]) → object :¶
bool ExtractTransform(Transform & t, std::vector< dReal >::const_iterator itdata, KinBodyConstPtr pbody, int timederivative = 0 )
extracts an affine transform given the start of a configuration space point
- Parameters
- inout] -
- t the transform holding the default values, which will be overwritten with the new values.
- itdata -
- data in the format of this configuration specification.
- timederivative -
- the time derivative of the data to extract Looks for ‘affine_transform’ groups. If pbody is not initialized, will choose the first affine_transform found.
- Return
- true if at least one group was found for extracting
- FindCompatibleGroup((ConfigurationSpecification)arg1, (str)arg2, (bool)arg3) → object :¶
std::vector< Group >::const_iterator FindCompatibleGroup(const Group & g, bool exactmatch = false )
finds the most compatible group to the given group
- Parameters
- g -
- the group to query, only the Group::name and Group::dof values are used
- exactmatch -
- if true, will only return groups whose name exactly matches with g.name
- Return
- an iterator part of _vgroups that represents the most compatible group. If no group is found, will return _vgroups.end()
- FindTimeDerivativeGroup((ConfigurationSpecification)arg1, (str)arg2, (bool)arg3) → object :¶
std::vector< Group >::const_iterator FindTimeDerivativeGroup(const Group & g, bool exactmatch = false )
Return the most compatible group that represents the time-derivative data of the group.
- Parameters
- g -
- the group to query, only the Group::name and Group::dof values are used
- exactmatch -
- if true, will only return groups whose name exactly matches with g.name For example given a ‘joint_values’ group, this will return the closest ‘joint_velocities’ group.
- Return
- an iterator part of _vgroups that represents the most compatible group. If no group is found, will return _vgroups.end()
- GetDOF((ConfigurationSpecification)arg1) → int :¶
int GetDOF()
return the dimension of the configuraiton space (degrees of freedom)
- GetGroupFromName((ConfigurationSpecification)arg1, (str)arg2) → Group :¶
const Group & GetGroupFromName(const std::string & name)
return the group whose name begins with a particular string.
- Exceptions
- openrave_exception -
- if a group is not found If multiple groups exist that begin with the same string, then the shortest one is returned.
- GetTimeDerivativeSpecification((ConfigurationSpecification)arg1, (int)arg2) → ConfigurationSpecification :¶
ConfigurationSpecification GetTimeDerivativeSpecification(int timederivative)
returns a new specification of just particular time-derivative groups.
- Parameters
- timederivative -
- the time derivative to query groups from. 0 is positions/joint values, 1 is velocities, 2 is accelerations, etc
- class Group¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
- dof¶
- interpolation¶
- name¶
- offset¶
- ConfigurationSpecification.InsertDeltaTime((ConfigurationSpecification)arg1, (object)data, (float)deltatime) → bool :¶
bool InsertDeltaTime(std::vector< dReal >::iterator itdata, dReal deltatime)
sets the deltatime field of the data if one exists
- Parameters
- inout] -
- itdata data in the format of this configuration specification.
- deltatime -
- the delta time of the time stamp (from previous point)
- Return
- true if at least one group was found for inserting
- ConfigurationSpecification.InsertJointValues((ConfigurationSpecification)arg1, (object)data, (object)values, (KinBody)body, (object)indices, (int)timederivative) → bool¶
- ConfigurationSpecification.IsValid((ConfigurationSpecification)arg1) → bool :¶
bool IsValid()
check if the groups form a continguous space
If there are two or more groups with the same semantic names, will fail. Theese groups should be merged into one.
- Return
- true if valid, otherwise false
- ConfigurationSpecification.ResetGroupOffsets((ConfigurationSpecification)arg1) → None :¶
void ResetGroupOffsets()
set the offsets of each group in order to get a contiguous configuration space
- class openravepy.openravepy_int.Contact¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
- depth¶
- norm¶
- pos¶
- class openravepy.openravepy_int.Controller¶
Bases: openravepy.openravepy_int.Interface
Raises an exception This class cannot be instantiated from Python
- GetControlDOFIndices((Controller)arg1) → object :¶
const std::vector< int > & GetControlDOFIndices()
returns the dof indices controlled
- GetRobot((Controller)arg1) → object :¶
RobotBasePtr GetRobot()
- GetTime((Controller)arg1) → float :¶
dReal GetTime()
return the time along the current command
- GetTorque((Controller)arg1) → object :¶
void GetTorque(std::vector< dReal > & torque)
- Parameters
- torque -
- [out] - returns the current torque/current/strain exerted by each of the dofs from outside forces. The feedforward and friction terms should be subtracted out already get torque/current/strain values
- GetVelocity((Controller)arg1) → object :¶
void GetVelocity(std::vector< dReal > & vel)
get velocity of the controlled DOFs
- Parameters
- vel -
- [out] - current velocity of robot from the dof
- Init((Controller)arg1, (Robot)arg2, (str)arg3) → bool :¶
bool Init(RobotBasePtr robot, const std::vector< int > & dofindices, int nControlTransformation)
initializes the controller and specifies the controlled dof
- Parameters
- robot -
- the robot that uses the controller
- dofindices -
- the indices that controller will have exclusive access to
nControlTransformation -
- See
- IsControlTransformation
- Return
- true on successful initialization
Init( (Controller)arg1, (Robot)robot, (object)dofindices, (int)controltransform) -> bool :
bool Init(RobotBasePtr robot, const std::vector< int > & dofindices, int nControlTransformation)
initializes the controller and specifies the controlled dof
- Parameters
- robot -
- the robot that uses the controller
- dofindices -
- the indices that controller will have exclusive access to
nControlTransformation -
- See
- IsControlTransformation
- Return
- true on successful initialization
- IsControlTransformation((Controller)arg1) → int :¶
int IsControlTransformation()
returns non-zero value if base affine transformation is controlled.
Only one controller can modify translation and orientation per robot. For now, the two cannot be divided.
- IsDone((Controller)arg1) → bool :¶
bool IsDone()
Return true when goal reached.
If a trajectory was set, return only when trajectory is done. If SetDesired was called, return only when robot is is at the desired location. If SendCommand sent, returns true when the command was completed by the hand.
- Reset((Controller)arg1[, (int)options]) → None :¶
void Reset(int options = 0 )
Resets the current controller trajectories and any other state associated with the robot.
- Parameters
- options -
- specific options that can be used to control what to reset
- SetDesired((Controller)arg1, (object)values) → bool :¶
bool SetDesired(const std::vector< dReal > & values, TransformConstPtr trans = TransformConstPtr () )
go to a specific position in configuration space.
- Parameters
- values -
- the final configuration in the control dofs
- trans -
- the transformation of the base. If not specified will use the current robot transformation. Ignored if controller does not use it
- Return
- true if position operation successful.
SetDesired( (Controller)arg1, (object)values, (object)transform) -> bool :
bool SetDesired(const std::vector< dReal > & values, TransformConstPtr trans = TransformConstPtr () )
go to a specific position in configuration space.
- Parameters
- values -
- the final configuration in the control dofs
- trans -
- the transformation of the base. If not specified will use the current robot transformation. Ignored if controller does not use it
- Return
- true if position operation successful.
- SetPath((Controller)arg1, (Trajectory)arg2) → bool :¶
bool SetPath(TrajectoryBaseConstPtr ptraj)
Follow a path in configuration space, adds to the queue of trajectories already in execution.
- Parameters
- ptraj -
- the trajectory
- Return
- true if trajectory operation successful
- SimulationStep((Controller)arg1, (float)arg2) → None :¶
void SimulationStep(dReal fTimeElapsed)
Simulate one step forward for controllers running in the simulation environment.
- Parameters
- fTimeElapsed -
- time elapsed in simulation environment since last frame
- class openravepy.openravepy_int.DOFAffine¶
Bases: Boost.Python.enum
DOFAffine
Selects which DOFs of the affine transformation to include in the active configuration.- NoTransform = openravepy.openravepy_int.DOFAffine.NoTransform¶
- Rotation3D = openravepy.openravepy_int.DOFAffine.Rotation3D¶
- RotationAxis = openravepy.openravepy_int.DOFAffine.RotationAxis¶
- RotationMask = openravepy.openravepy_int.DOFAffine.RotationMask¶
- RotationQuat = openravepy.openravepy_int.DOFAffine.RotationQuat¶
- Transform = openravepy.openravepy_int.DOFAffine.Transform¶
- X = openravepy.openravepy_int.DOFAffine.X¶
- Y = openravepy.openravepy_int.DOFAffine.Y¶
- Z = openravepy.openravepy_int.DOFAffine.Z¶
- names = {'NoTransform': openravepy.openravepy_int.DOFAffine.NoTransform, 'Rotation3D': openravepy.openravepy_int.DOFAffine.Rotation3D, 'RotationQuat': openravepy.openravepy_int.DOFAffine.RotationQuat, 'RotationAxis': openravepy.openravepy_int.DOFAffine.RotationAxis, 'Transform': openravepy.openravepy_int.DOFAffine.Transform, 'RotationMask': openravepy.openravepy_int.DOFAffine.RotationMask, 'Y': openravepy.openravepy_int.DOFAffine.Y, 'X': openravepy.openravepy_int.DOFAffine.X, 'Z': openravepy.openravepy_int.DOFAffine.Z}¶
- values = {0: openravepy.openravepy_int.DOFAffine.NoTransform, 1: openravepy.openravepy_int.DOFAffine.X, 2: openravepy.openravepy_int.DOFAffine.Y, 4: openravepy.openravepy_int.DOFAffine.Z, 32: openravepy.openravepy_int.DOFAffine.RotationQuat, 8: openravepy.openravepy_int.DOFAffine.RotationAxis, 39: openravepy.openravepy_int.DOFAffine.Transform, 16: openravepy.openravepy_int.DOFAffine.Rotation3D, 56: openravepy.openravepy_int.DOFAffine.RotationMask}¶
- class openravepy.openravepy_int.DebugLevel¶
Bases: Boost.Python.enum
DebugLevel
- Debug = openravepy.openravepy_int.DebugLevel.Debug¶
- Error = openravepy.openravepy_int.DebugLevel.Error¶
- Fatal = openravepy.openravepy_int.DebugLevel.Fatal¶
- Info = openravepy.openravepy_int.DebugLevel.Info¶
- Verbose = openravepy.openravepy_int.DebugLevel.Verbose¶
- VerifyPlans = openravepy.openravepy_int.DebugLevel.VerifyPlans¶
- Warn = openravepy.openravepy_int.DebugLevel.Warn¶
- names = {'Info': openravepy.openravepy_int.DebugLevel.Info, 'VerifyPlans': openravepy.openravepy_int.DebugLevel.VerifyPlans, 'Verbose': openravepy.openravepy_int.DebugLevel.Verbose, 'Warn': openravepy.openravepy_int.DebugLevel.Warn, 'Error': openravepy.openravepy_int.DebugLevel.Error, 'Debug': openravepy.openravepy_int.DebugLevel.Debug, 'Fatal': openravepy.openravepy_int.DebugLevel.Fatal}¶
- values = {0: openravepy.openravepy_int.DebugLevel.Fatal, 1: openravepy.openravepy_int.DebugLevel.Error, 2: openravepy.openravepy_int.DebugLevel.Warn, 3: openravepy.openravepy_int.DebugLevel.Info, 4: openravepy.openravepy_int.DebugLevel.Debug, 5: openravepy.openravepy_int.DebugLevel.Verbose, 2147483648: openravepy.openravepy_int.DebugLevel.VerifyPlans}¶
- class openravepy.openravepy_int.Environment¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
__init__( (object)arg1) -> None
- Add((Environment)arg1, (Interface)interface[, (bool)anonymous[, (str)cmdargs]]) → None :¶
void Add(InterfaceBasePtr pinterface, bool bAnonymous = false , const std::string & cmdargs = “” )
Add an interface to the environment.
- Parameters
- pinterface -
- the pointer to an initialized interface
- bAnonymous -
- if true and there exists a body/robot with the same name, will make body’s name unique
- cmdargs -
- The command-line arguments for the module. Exceptions
- openrave_exception -
- Throw if interface is invalid or already added Depending on the type of interface, the addition behaves differently. For bodies/robots, will add them to visual/geometric environment. For modules, will call their main() method and add them officially. For viewers, will attach a viewer to the environment and start sending it data. For interfaces that don’t make sense to add, will throw an exception.
- AddKinBody((Environment)arg1, (KinBody)body) → None :¶
- void AddKinBody(KinBodyPtr body, bool bAnonymous = false )
AddKinBody( (Environment)arg1, (KinBody)body, (bool)anonymous) -> None :
void AddKinBody(KinBodyPtr body, bool bAnonymous = false )
- AddModule((Environment)arg1, (Module)module, (str)args) → int :¶
int AddModule(ModuleBasePtr module, const std::string & cmdargs)
Load a new module, need to Lock if calling outside simulation thread.
- AddRobot((Environment)arg1, (Robot)robot) → None :¶
- void AddRobot(RobotBasePtr robot, bool bAnonymous = false )
AddRobot( (Environment)arg1, (Robot)robot, (bool)anonymous) -> None :
void AddRobot(RobotBasePtr robot, bool bAnonymous = false )
- AddSensor((Environment)arg1, (Sensor)sensor) → None :¶
- void AddSensor(SensorBasePtr sensor, bool bAnonymous = false )
AddSensor( (Environment)arg1, (Sensor)sensor, (bool)anonymous) -> None :
void AddSensor(SensorBasePtr sensor, bool bAnonymous = false )
- AddViewer((Environment)arg1, (Sensor)sensor, (bool)anonymous) → None :¶
void AddViewer(ViewerBasePtr pviewer)
- CheckCollision((Environment)arg1, (KinBody)body) → bool :¶
bool CheckCollision(KinBodyConstPtr pbody1, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(KinBodyConstPtr,CollisionReportPtr)
CheckCollision( (Environment)arg1, (KinBody)body, (CollisionReport)report) -> bool :
bool CheckCollision(KinBodyConstPtr pbody1, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(KinBodyConstPtr,CollisionReportPtr)
CheckCollision( (Environment)arg1, (KinBody)body1, (KinBody)body2) -> bool :
bool CheckCollision(KinBodyConstPtr pbody1, KinBodyConstPtr pbody2, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(KinBodyConstPtr,KinBodyConstPtr,CollisionReportPtr)
CheckCollision( (Environment)arg1, (KinBody)body1, (KinBody)body2, (CollisionReport)report) -> bool :
bool CheckCollision(KinBodyConstPtr pbody1, KinBodyConstPtr pbody2, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(KinBodyConstPtr,KinBodyConstPtr,CollisionReportPtr)
CheckCollision( (Environment)arg1, (object)link) -> bool :
bool CheckCollision(KinBody::LinkConstPtr plink, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(KinBody::LinkConstPtr,CollisionReportPtr)
CheckCollision( (Environment)arg1, (object)link, (CollisionReport)report) -> bool :
bool CheckCollision(KinBody::LinkConstPtr plink, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(KinBody::LinkConstPtr,CollisionReportPtr)
CheckCollision( (Environment)arg1, (object)link1, (object)link2) -> bool :
bool CheckCollision(KinBody::LinkConstPtr plink1, KinBody::LinkConstPtr plink2, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(KinBody::LinkConstPtr,KinBody::LinkConstPtr,CollisionReportPtr)
CheckCollision( (Environment)arg1, (object)link1, (object)link2, (CollisionReport)report) -> bool :
bool CheckCollision(KinBody::LinkConstPtr plink1, KinBody::LinkConstPtr plink2, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(KinBody::LinkConstPtr,KinBody::LinkConstPtr,CollisionReportPtr)
CheckCollision( (Environment)arg1, (object)link, (KinBody)body) -> bool :
bool CheckCollision(KinBody::LinkConstPtr plink, KinBodyConstPtr pbody, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(KinBody::LinkConstPtr,KinBodyConstPtr,CollisionReportPtr)
CheckCollision( (Environment)arg1, (object)link, (KinBody)body, (CollisionReport)report) -> bool :
bool CheckCollision(KinBody::LinkConstPtr plink, KinBodyConstPtr pbody, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(KinBody::LinkConstPtr,KinBodyConstPtr,CollisionReportPtr)
CheckCollision( (Environment)arg1, (object)link, (object)bodyexcluded, (object)linkexcluded) -> bool :
bool CheckCollision(KinBody::LinkConstPtr plink, const std::vector< KinBodyConstPtr > & vbodyexcluded, const std::vector< KinBody::LinkConstPtr > & vlinkexcluded, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(KinBody::LinkConstPtr,const std::vector<KinBodyConstPtr>&,const std::vector<KinBody::LinkConstPtr>&,CollisionReportPtr)
CheckCollision( (Environment)arg1, (object)link, (object)bodyexcluded, (object)linkexcluded, (CollisionReport)report) -> bool :
bool CheckCollision(KinBody::LinkConstPtr plink, const std::vector< KinBodyConstPtr > & vbodyexcluded, const std::vector< KinBody::LinkConstPtr > & vlinkexcluded, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(KinBody::LinkConstPtr,const std::vector<KinBodyConstPtr>&,const std::vector<KinBody::LinkConstPtr>&,CollisionReportPtr)
CheckCollision( (Environment)arg1, (KinBody)body, (object)bodyexcluded, (object)linkexcluded) -> bool :
bool CheckCollision(KinBodyConstPtr pbody, const std::vector< KinBodyConstPtr > & vbodyexcluded, const std::vector< KinBody::LinkConstPtr > & vlinkexcluded, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(KinBodyConstPtr,const std::vector<KinBodyConstPtr>&,const std::vector<KinBody::LinkConstPtr>&,CollisionReportPtr)
CheckCollision( (Environment)arg1, (KinBody)body, (object)bodyexcluded, (object)linkexcluded, (CollisionReport)report) -> bool :
bool CheckCollision(KinBodyConstPtr pbody, const std::vector< KinBodyConstPtr > & vbodyexcluded, const std::vector< KinBody::LinkConstPtr > & vlinkexcluded, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(KinBodyConstPtr,const std::vector<KinBodyConstPtr>&,const std::vector<KinBody::LinkConstPtr>&,CollisionReportPtr)
CheckCollision( (Environment)arg1, (Ray)ray, (KinBody)body) -> bool :
bool CheckCollision(const RAY & ray, KinBodyConstPtr pbody, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(const RAY&,KinBodyConstPtr,CollisionReportPtr)
CheckCollision( (Environment)arg1, (Ray)ray, (KinBody)body, (CollisionReport)report) -> bool :
bool CheckCollision(const RAY & ray, KinBodyConstPtr pbody, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(const RAY&,KinBodyConstPtr,CollisionReportPtr)
CheckCollision( (Environment)arg1, (Ray)ray) -> bool :
bool CheckCollision(const RAY & ray, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(const RAY&,CollisionReportPtr)
CheckCollision( (Environment)arg1, (Ray)arg2, (CollisionReport)ray) -> bool :
bool CheckCollision(const RAY & ray, CollisionReportPtr report = CollisionReportPtr () )
- See
- CollisionCheckerBase::CheckCollision(const RAY&,CollisionReportPtr)
- CheckCollisionRays((Environment)arg1, (object)rays, (KinBody)body[, (bool)front_facing_only]) → object :¶
Check if any rays hit the body and returns their contact points along with a vector specifying if a collision occured or not. Rays is a Nx6 array, first 3 columsn are position, last 3 are direction+range.
- Clone((Environment)arg1, (Environment)reference, (int)options) → None :¶
void Clone(EnvironmentBaseConstPtr preference, int cloningoptions)
Clones the reference environment into the current environment.
- Parameters
- cloningoptions -
- The parts of the environment to clone. Parts not specified are left as is. Tries to preserve computation by re-using bodies/interfaces that are already similar between the current and reference environments.
- CloneSelf((Environment)arg1, (int)options) → Environment :¶
EnvironmentBasePtr CloneSelf(int options)
Create and return a clone of the current environment.
- Parameters
- options -
- A set of CloningOptions describing what is actually cloned. Clones do not share any memory or resource between each other. or their parent making them ideal for performing separte planning experiments while keeping the parent environment unchanged. By default a clone only copies the collision checkers and physics engine. When bodies are cloned, the unique ids are preserved across environments (each body can be referenced with its id in both environments). The attached and grabbed bodies of each body/robot are also copied to the new environment.
- Return
- An environment of the same type as this environment containing the copied information.
- Destroy((Environment)arg1) → None :¶
void Destroy()
Releases all environment resources, should be always called when environment stops being used.
Removing all environment pointer might not be enough to destroy the environment resources.
- GetBodies((Environment)arg1) → object :¶
void GetBodies(std::vector< KinBodyPtr > & bodies, uint64_t timeout = 0 )
Get all bodies loaded in the environment (including robots).
- Parameters
- bodies -
- filled with all the bodies
- timeout -
- microseconds to wait before throwing an exception, if 0, will block indefinitely. Exceptions
- openrave_exception -
- with ORE_Timeout error code A separate is locked for reading the bodies.
- GetBodyFromEnvironmentId((Environment)arg1, (int)arg2) → object :¶
KinBodyPtr GetBodyFromEnvironmentId(int id)
Get the corresponding body from its unique network id.
- GetCollisionChecker((Environment)arg1) → object :¶
CollisionCheckerBasePtr GetCollisionChecker()
- GetDebugLevel((Environment)arg1) → int :¶
int GetDebugLevel()
- GetHomeDirectory((Environment)arg1) → str :¶
std::string GetHomeDirectory()
- GetKinBody((Environment)arg1, (str)name) → object :¶
KinBodyPtr GetKinBody(const std::string & name)
Query a body from its name.
- Return
- first KinBody (including robots) that matches with name
- GetLoadedProblems((Environment)arg1) → object :¶
void GetModules(std::list< ModuleBasePtr > & listModules, uint64_t timeout = 0 )
Fills a list with the loaded modules in the environment.
- Parameters
- timeout -
- microseconds to wait before throwing an exception, if 0, will block indefinitely. Exceptions
- openrave_exception -
- with ORE_Timeout error code A separate is locked for reading the modules. If the environment is locked, the modules are guaranteed to stay loaded in the environment.
- GetModules((Environment)arg1) → object :¶
void GetModules(std::list< ModuleBasePtr > & listModules, uint64_t timeout = 0 )
Fills a list with the loaded modules in the environment.
- Parameters
- timeout -
- microseconds to wait before throwing an exception, if 0, will block indefinitely. Exceptions
- openrave_exception -
- with ORE_Timeout error code A separate is locked for reading the modules. If the environment is locked, the modules are guaranteed to stay loaded in the environment.
- GetPhysicsEngine((Environment)arg1) → object :¶
PhysicsEngineBasePtr GetPhysicsEngine()
- GetRobot((Environment)arg1, (str)name) → object :¶
RobotBasePtr GetRobot(const std::string & name)
Query a robot from its name.
- Return
- first Robot that matches the name
- GetRobots((Environment)arg1) → object :¶
void GetRobots(std::vector< RobotBasePtr > & robots, uint64_t timeout = 0 )
Fill an array with all robots loaded in the environment.
- Parameters
- timeout -
- microseconds to wait before throwing an exception, if 0, will block indefinitely. Exceptions
- openrave_exception -
- with ORE_Timeout error code A separate is locked for reading the bodies.
- GetSensor((Environment)arg1, (str)name) → object :¶
SensorBasePtr GetSensor(const std::string & name)
Query a sensor from its name.
- Return
- first sensor that matches with name, note that sensors attached to robots have the robot name as a prefix.
- GetSensors((Environment)arg1) → object :¶
void GetSensors(std::vector< SensorBasePtr > & sensors, uint64_t timeout = 0 )
Fill an array with all sensors loaded in the environment.
- Parameters
- timeout -
- microseconds to wait before throwing an exception, if 0, will block indefinitely. Exceptions
- openrave_exception -
- with ORE_Timeout error code The sensors come from the currently loaded robots and the explicitly added sensors
- GetSimulationTime((Environment)arg1) → int :¶
uint64_t GetSimulationTime()
Return simulation time since the start of the environment (in microseconds).
See Simulation Thread for more about the simulation thread.
- GetUserData((Environment)arg1) → object :¶
UserDataPtr GetUserData()
return the user custom data
- GetViewer((Environment)arg1) → object :¶
ViewerBasePtr GetViewer(const std::string & name = “” )
Return a viewer with a particular name.
When no name is specified, the first loaded viewer is returned.
- HasRegisteredCollisionCallbacks((Environment)arg1) → bool¶
- IsSimulationRunning((Environment)arg1) → bool¶
- Load((Environment)arg1, (str)filename) → bool :¶
bool Load(const std::string & filename, const AttributesList & atts = AttributesList () )
Loads a scene from a file and adds all objects in the environment.
For collada readers, the options are passed through to
Load( (Environment)arg1, (str)filename, (object)atts) -> bool :
bool Load(const std::string & filename, const AttributesList & atts = AttributesList () )
Loads a scene from a file and adds all objects in the environment.
For collada readers, the options are passed through to
- LoadData((Environment)arg1, (str)data) → bool :¶
bool LoadData(const std::string & data, const AttributesList & atts = AttributesList () )
Loads a scene from in-memory data and adds all objects in the environment.LoadData( (Environment)arg1, (str)data, (object)atts) -> bool :
bool LoadData(const std::string & data, const AttributesList & atts = AttributesList () )
Loads a scene from in-memory data and adds all objects in the environment.
- LoadProblem((Environment)arg1, (Module)module, (str)args) → int :¶
int AddModule(ModuleBasePtr module, const std::string & cmdargs)
Load a new module, need to Lock if calling outside simulation thread.
- LoadURI((Environment)arg1, (str)filename[, (object)atts]) → bool :¶
bool LoadURI(const std::string & filename, const AttributesList & atts = AttributesList () )
Loads a scene from a URI and adds all objects in the environment.
Currently only collada files are supported. Options are passed through to
- Lock((Environment)arg1) → None :¶
Locks the environment mutex.
- LockPhysics((Environment)lock) → None :¶
- Locks the environment mutex.
- LockPhysics( (Environment)lock, (float)timeout) -> None :
- Locks the environment mutex with a timeout.
- ReadInterfaceURI((Environment)arg1, (str)filename) → Interface :¶
InterfaceBasePtr ReadInterfaceURI(InterfaceBasePtr pinterface, InterfaceType type, const std::string & filename, const AttributesList & atts = AttributesList () )
Initializes an interface from a resource file.
- Parameters
- pinterface -
- If a null pointer is passed, a new interface will be created, otherwise an existing interface will be filled
- filename -
- the name of the resource file, its extension determines the format of the file. See Resource File Formats.
- atts -
- The attribute/value pair specifying loading options. See the individual interface descriptions at Base Interface Concepts.
ReadInterfaceURI( (Environment)arg1, (str)filename, (object)atts) -> Interface :
InterfaceBasePtr ReadInterfaceURI(InterfaceBasePtr pinterface, InterfaceType type, const std::string & filename, const AttributesList & atts = AttributesList () )
Initializes an interface from a resource file.
- Parameters
- pinterface -
- If a null pointer is passed, a new interface will be created, otherwise an existing interface will be filled
- filename -
- the name of the resource file, its extension determines the format of the file. See Resource File Formats.
- atts -
- The attribute/value pair specifying loading options. See the individual interface descriptions at Base Interface Concepts.
- ReadInterfaceXMLFile((Environment)arg1, (str)filename) → Interface :¶
InterfaceBasePtr ReadInterfaceURI(InterfaceBasePtr pinterface, InterfaceType type, const std::string & filename, const AttributesList & atts = AttributesList () )
Initializes an interface from a resource file.
- Parameters
- pinterface -
- If a null pointer is passed, a new interface will be created, otherwise an existing interface will be filled
- filename -
- the name of the resource file, its extension determines the format of the file. See Resource File Formats.
- atts -
- The attribute/value pair specifying loading options. See the individual interface descriptions at Base Interface Concepts.
ReadInterfaceXMLFile( (Environment)arg1, (str)filename, (object)atts) -> Interface :
InterfaceBasePtr ReadInterfaceURI(InterfaceBasePtr pinterface, InterfaceType type, const std::string & filename, const AttributesList & atts = AttributesList () )
Initializes an interface from a resource file.
- Parameters
- pinterface -
- If a null pointer is passed, a new interface will be created, otherwise an existing interface will be filled
- filename -
- the name of the resource file, its extension determines the format of the file. See Resource File Formats.
- atts -
- The attribute/value pair specifying loading options. See the individual interface descriptions at Base Interface Concepts.
- ReadKinBodyData((Environment)arg1, (str)data) → object :¶
KinBodyPtr ReadKinBodyData(KinBodyPtr body, const std::string & data, const AttributesList & atts = AttributesList () )
Initializes a kinematic body from in-memory data.
- Parameters
- body -
- If a null pointer is passed, a new body will be created, otherwise an existing robot will be filled
- atts -
- The attribute/value pair specifying loading options. Defined in Kinematics Body Concepts. The body should not be added to the environment when calling this function.
ReadKinBodyData( (Environment)arg1, (str)data, (object)atts) -> object :
KinBodyPtr ReadKinBodyData(KinBodyPtr body, const std::string & data, const AttributesList & atts = AttributesList () )
Initializes a kinematic body from in-memory data.
- Parameters
- body -
- If a null pointer is passed, a new body will be created, otherwise an existing robot will be filled
- atts -
- The attribute/value pair specifying loading options. Defined in Kinematics Body Concepts. The body should not be added to the environment when calling this function.
- ReadKinBodyURI((Environment)arg1, (str)filename) → object :¶
KinBodyPtr ReadKinBodyURI(const std::string & filename)
Creates a new kinbody from an XML file with no extra load options specified.ReadKinBodyURI( (Environment)arg1, (str)filename, (object)atts) -> object :
KinBodyPtr ReadKinBodyURI(KinBodyPtr body, const std::string & filename, const AttributesList & atts = AttributesList () )
Initializes a kinematic body from a resource file. The body is not added to the environment when calling this function.
- Parameters
- filename -
- the name of the resource file, its extension determines the format of the file. See Resource File Formats.
- body -
- If a null pointer is passed, a new body will be created, otherwise an existing robot will be filled
- atts -
- The attribute/value pair specifying loading options. Defined in Kinematics Body Concepts.
- ReadKinBodyXMLData((Environment)arg1, (str)data) → object :¶
KinBodyPtr ReadKinBodyData(KinBodyPtr body, const std::string & data, const AttributesList & atts = AttributesList () )
Initializes a kinematic body from in-memory data.
- Parameters
- body -
- If a null pointer is passed, a new body will be created, otherwise an existing robot will be filled
- atts -
- The attribute/value pair specifying loading options. Defined in Kinematics Body Concepts. The body should not be added to the environment when calling this function.
ReadKinBodyXMLData( (Environment)arg1, (str)data, (object)atts) -> object :
KinBodyPtr ReadKinBodyData(KinBodyPtr body, const std::string & data, const AttributesList & atts = AttributesList () )
Initializes a kinematic body from in-memory data.
- Parameters
- body -
- If a null pointer is passed, a new body will be created, otherwise an existing robot will be filled
- atts -
- The attribute/value pair specifying loading options. Defined in Kinematics Body Concepts. The body should not be added to the environment when calling this function.
- ReadKinBodyXMLFile((Environment)arg1, (str)filename) → object :¶
KinBodyPtr ReadKinBodyURI(const std::string & filename)
Creates a new kinbody from an XML file with no extra load options specified.ReadKinBodyXMLFile( (Environment)arg1, (str)filename, (object)atts) -> object :
KinBodyPtr ReadKinBodyURI(KinBodyPtr body, const std::string & filename, const AttributesList & atts = AttributesList () )
Initializes a kinematic body from a resource file. The body is not added to the environment when calling this function.
- Parameters
- filename -
- the name of the resource file, its extension determines the format of the file. See Resource File Formats.
- body -
- If a null pointer is passed, a new body will be created, otherwise an existing robot will be filled
- atts -
- The attribute/value pair specifying loading options. Defined in Kinematics Body Concepts.
- ReadRobotData((Environment)arg1, (str)data) → object :¶
RobotBasePtr ReadRobotData(RobotBasePtr robot, const std::string & data, const AttributesList & atts = AttributesList () )
Initialize a robot from in-memory data.
- Parameters
- robot -
- If a null pointer is passed, a new robot will be created, otherwise an existing robot will be filled
- atts -
- The attribute/value pair specifying loading options. Defined in Robot Concepts. The robot should not be added the environment when calling this function.
ReadRobotData( (Environment)arg1, (str)data, (object)atts) -> object :
RobotBasePtr ReadRobotData(RobotBasePtr robot, const std::string & data, const AttributesList & atts = AttributesList () )
Initialize a robot from in-memory data.
- Parameters
- robot -
- If a null pointer is passed, a new robot will be created, otherwise an existing robot will be filled
- atts -
- The attribute/value pair specifying loading options. Defined in Robot Concepts. The robot should not be added the environment when calling this function.
- ReadRobotURI((Environment)arg1, (str)filename) → object :¶
RobotBasePtr ReadRobotURI(const std::string & filename)
Creates a new robot from a file with no extra load options specified.ReadRobotURI( (Environment)arg1, (str)filename, (object)atts) -> object :
RobotBasePtr ReadRobotURI(RobotBasePtr robot, const std::string & filename, const AttributesList & atts = AttributesList () )
Initializes a robot from a resource file. The robot is not added to the environment when calling this function.
- Parameters
- robot -
- If a null pointer is passed, a new robot will be created, otherwise an existing robot will be filled
- filename -
- the name of the resource file, its extension determines the format of the file. See Resource File Formats.
- atts -
- The attribute/value pair specifying loading options. Defined in Robot Concepts.
- ReadRobotXMLData((Environment)arg1, (str)data) → object :¶
RobotBasePtr ReadRobotData(RobotBasePtr robot, const std::string & data, const AttributesList & atts = AttributesList () )
Initialize a robot from in-memory data.
- Parameters
- robot -
- If a null pointer is passed, a new robot will be created, otherwise an existing robot will be filled
- atts -
- The attribute/value pair specifying loading options. Defined in Robot Concepts. The robot should not be added the environment when calling this function.
ReadRobotXMLData( (Environment)arg1, (str)data, (object)atts) -> object :
RobotBasePtr ReadRobotData(RobotBasePtr robot, const std::string & data, const AttributesList & atts = AttributesList () )
Initialize a robot from in-memory data.
- Parameters
- robot -
- If a null pointer is passed, a new robot will be created, otherwise an existing robot will be filled
- atts -
- The attribute/value pair specifying loading options. Defined in Robot Concepts. The robot should not be added the environment when calling this function.
- ReadRobotXMLFile((Environment)arg1, (str)filename) → object :¶
RobotBasePtr ReadRobotURI(const std::string & filename)
Creates a new robot from a file with no extra load options specified.ReadRobotXMLFile( (Environment)arg1, (str)filename, (object)atts) -> object :
RobotBasePtr ReadRobotURI(RobotBasePtr robot, const std::string & filename, const AttributesList & atts = AttributesList () )
Initializes a robot from a resource file. The robot is not added to the environment when calling this function.
- Parameters
- robot -
- If a null pointer is passed, a new robot will be created, otherwise an existing robot will be filled
- filename -
- the name of the resource file, its extension determines the format of the file. See Resource File Formats.
- atts -
- The attribute/value pair specifying loading options. Defined in Robot Concepts.
- ReadTrimeshFile((Environment)arg1, (str)filename) → object :¶
boost::shared_ptr< KinBody::Link::TRIMESH > ReadTrimeshURI(boost::shared_ptr< KinBody::Link::TRIMESH > ptrimesh, const std::string & filename, const AttributesList & atts = AttributesList () )
reads in the rigid geometry of a resource file into a TRIMESH structure
- Parameters
- filename -
- the name of the resource file, its extension determines the format of the file. Complex meshes and articulated meshes are all triangulated appropriately. See Resource File Formats.
- options -
- Options to control the parsing process.
ReadTrimeshFile( (Environment)arg1, (str)filename, (object)atts) -> object :
boost::shared_ptr< KinBody::Link::TRIMESH > ReadTrimeshURI(boost::shared_ptr< KinBody::Link::TRIMESH > ptrimesh, const std::string & filename, const AttributesList & atts = AttributesList () )
reads in the rigid geometry of a resource file into a TRIMESH structure
- Parameters
- filename -
- the name of the resource file, its extension determines the format of the file. Complex meshes and articulated meshes are all triangulated appropriately. See Resource File Formats.
- options -
- Options to control the parsing process.
- ReadTrimeshURI((Environment)arg1, (str)filename) → object :¶
boost::shared_ptr< KinBody::Link::TRIMESH > ReadTrimeshURI(boost::shared_ptr< KinBody::Link::TRIMESH > ptrimesh, const std::string & filename, const AttributesList & atts = AttributesList () )
reads in the rigid geometry of a resource file into a TRIMESH structure
- Parameters
- filename -
- the name of the resource file, its extension determines the format of the file. Complex meshes and articulated meshes are all triangulated appropriately. See Resource File Formats.
- options -
- Options to control the parsing process.
ReadTrimeshURI( (Environment)arg1, (str)filename, (object)atts) -> object :
boost::shared_ptr< KinBody::Link::TRIMESH > ReadTrimeshURI(boost::shared_ptr< KinBody::Link::TRIMESH > ptrimesh, const std::string & filename, const AttributesList & atts = AttributesList () )
reads in the rigid geometry of a resource file into a TRIMESH structure
- Parameters
- filename -
- the name of the resource file, its extension determines the format of the file. Complex meshes and articulated meshes are all triangulated appropriately. See Resource File Formats.
- options -
- Options to control the parsing process.
- RegisterCollisionCallback((Environment)arg1, (object)callback) → object :¶
UserDataPtr RegisterCollisionCallback(const CollisionCallbackFn & callback)
Register a collision callback.Whenever a collision is detected between between bodies during a CheckCollision call or physics simulation, the callback is called. The callback should return an action specifying how the collision should be handled:
- Return
- a handle to the registration, once the handle loses scope, the callback is unregistered
- Remove((Environment)arg1, (Interface)interface) → bool :¶
bool Remove(InterfaceBasePtr obj)
Removes a currently loaded interface from the environment.
- Parameters
- obj -
- interface to remove The function removes currently loaded bodies, robots, sensors, problems from the actively used interfaces of the environment. This does not destroy the interface, but it does remove all references managed. Some interfaces like problems have destroy methods that are called to signal unloading. Note that the active interfaces are different from the owned interfaces.
- Return
- true if the interface was successfully removed from the environment.
- RemoveKinBody((Environment)arg1, (KinBody)body) → bool :¶
bool RemoveKinBody(KinBodyPtr pbody)
remove body from sensory system. If bDestroy is true, will also deallocate the memory
- RemoveProblem((Environment)arg1, (Module)prob) → bool¶
- Reset((Environment)arg1) → None :¶
void Reset()
Resets all objects of the scene (preserves all problems, planners).
Do not call inside a SimulationStep call
- Save((Environment)arg1, (str)filename[, (SelectionOptions)options[, (object)atts]]) → None :¶
void Save(const std::string & filename, SelectionOptions options = SO_Everything , const AttributesList & atts = AttributesList () )
Saves a scene depending on the filename extension. Default is in COLLADA format.
- Parameters
- filename -
- the filename to save the results at
- options -
- controls what to save
- atts -
- attributes that refine further options. For collada parsing, the options are passed through Several default options are: Exceptions
- openrave_exception -
- Throw if failed to save anything
- class SelectionOptions¶
Bases: Boost.Python.enum
SelectionOptions
A set of options used to select particular parts of the scene.- AllExceptBody = openravepy.openravepy_int.SelectionOptions.AllExceptBody¶
- Body = openravepy.openravepy_int.SelectionOptions.Body¶
- Everything = openravepy.openravepy_int.SelectionOptions.Everything¶
- NoRobots = openravepy.openravepy_int.SelectionOptions.NoRobots¶
- Robots = openravepy.openravepy_int.SelectionOptions.Robots¶
- names = {'Body': openravepy.openravepy_int.SelectionOptions.Body, 'Everything': openravepy.openravepy_int.SelectionOptions.Everything, 'Robots': openravepy.openravepy_int.SelectionOptions.Robots, 'NoRobots': openravepy.openravepy_int.SelectionOptions.NoRobots, 'AllExceptBody': openravepy.openravepy_int.SelectionOptions.AllExceptBody}¶
- values = {1: openravepy.openravepy_int.SelectionOptions.NoRobots, 2: openravepy.openravepy_int.SelectionOptions.Robots, 3: openravepy.openravepy_int.SelectionOptions.Everything, 4: openravepy.openravepy_int.SelectionOptions.Body, 5: openravepy.openravepy_int.SelectionOptions.AllExceptBody}¶
- Environment.SetCollisionChecker((Environment)arg1, (CollisionChecker)collisionchecker) → bool :¶
bool SetCollisionChecker(CollisionCheckerBasePtr pchecker)
set the global environment collision checker
- Environment.SetDebugLevel((Environment)arg1, (object)level) → None :¶
void SetDebugLevel(int level)
- Parameters
- level -
- 0 for no debug, 1 - to print all debug messeges. Default value for release builds is 0, for debug builds it is 1 declaring variables with stdcall can be a little complex sets the debug level
- Environment.SetPhysicsEngine((Environment)arg1, (PhysicsEngine)physics) → bool :¶
bool SetPhysicsEngine(PhysicsEngineBasePtr physics)
- Parameters
- physics -
- the engine to set, if NULL, environment sets an dummy physics engine set the physics engine, disabled by default
- Environment.SetUserData((Environment)arg1, (UserData)data) → None :¶
void SetUserData(UserDataPtr data)
set user dataSetUserData( (Environment)arg1, (object)data) -> None :
void SetUserData(UserDataPtr data)
set user data
- Environment.SetViewer((Environment)arg1, (str)viewername[, (bool)showviewer]) → bool :¶
Attaches the viewer and starts its thread
- Environment.StartSimulation((Environment)arg1, (float)timestep[, (bool)realtime]) → None :¶
void StartSimulation(dReal fDeltaTime, bool bRealTime = true )
Start the internal simulation thread.
- Resets simulation time to 0. See Simulation Thread for more about the simulation thread.Parameters
- fDeltaTime -
- the delta step to take in simulation
- bRealTime -
- if false will call SimulateStep as fast as possible, otherwise will time the simulate step calls so that simulation progresses with real system time.
- Environment.StepSimulation((Environment)arg1, (float)timestep) → None :¶
void StepSimulation(dReal timeStep)
Makes one simulation time step.
Can be called manually by the user inside planners. Keep in mind that the internal simulation thread also calls this function periodically. See Simulation Thread for more about the simulation thread.
- Environment.StopSimulation((Environment)arg1) → None :¶
void StopSimulation()
Stops the internal physics loop, stops calling SimulateStep for all modules.
See Simulation Thread for more about the simulation thread.
- Environment.Triangulate((Environment)arg1, (KinBody)body) → object :¶
void Triangulate(KinBody::Link::TRIMESH & trimesh, KinBodyConstPtr pbody)
Triangulation of the body including its current transformation. trimesh will be appended the new data.
- Parameters
- trimesh -
- The output triangle mesh
- body -
- body the triangulate Exceptions
- openrave_exception -
- Throw if failed to add anything
- Environment.TriangulateOptions¶
alias of SelectionOptions
- Environment.TriangulateScene((Environment)arg1, (SelectionOptions)options, (str)name) → object :¶
void TriangulateScene(KinBody::Link::TRIMESH & trimesh, SelectionOptions options, const std::string & selectname)
General triangulation of the whole scene.
- Parameters
- trimesh -
- The output triangle mesh. The new triangles are appended to the existing triangles!
- options -
- Controlls what to triangulate.
- selectname -
- name of the body used in options Exceptions
- openrave_exception -
- Throw if failed to add anything
- Environment.Unlock((Environment)arg1) → None :¶
Unlocks the environment mutex.
- Environment.UpdatePublishedBodies((Environment)arg1) → None :¶
void UpdatePublishedBodies(uint64_t timeout = 0 )
Updates the published bodies that viewers and other programs listening in on the environment see.
- Parameters
- timeout -
- microseconds to wait before throwing an exception, if 0, will block indefinitely. Exceptions
- openrave_exception -
- with ORE_Timeout error code For example, calling this function inside a planning loop allows the viewer to update the environment reflecting the status of the planner. Assumes that the physics are locked.
- Environment.drawarrow((Environment)arg1, (object)p1, (object)p2[, (float)linewidth[, (object)color]]) → object :¶
OpenRAVE::GraphHandlePtr drawarrow(const RaveVector< float > & p1, const RaveVector< float > & p2, float fwidth, const RaveVector< float > & color = RaveVector< float >(1, 0.5, 0.5, 1) )
Draws an arrow p1 is start, p2 is finish.
- Parameters
- color -
- the rgb color of the point. The last component of the color is used for alpha blending.
- Return
- handle to plotted points, graph is removed when handle is destroyed (goes out of scope). This requires the user to always store the handle in a persistent variable if the plotted graphics are to remain on the viewer.
- Environment.drawbox((Environment)arg1, (object)pos, (object)extents[, (object)color]) → object :¶
OpenRAVE::GraphHandlePtr drawbox(const RaveVector< float > & vpos, const RaveVector< float > & vextents)
Draws a box.
extents are half the width, height, and depth of the box
- Return
- handle to plotted points, graph is removed when handle is destroyed (goes out of scope). This requires the user to always store the handle in a persistent variable if the plotted graphics are to remain on the viewer.
- Environment.drawlinelist((Environment)arg1, (object)points, (float)linewidth[, (object)colors[, (int)drawstyle]]) → object :¶
OpenRAVE::GraphHandlePtr drawlinelist(const float * ppoints, int numPoints, int stride, float fwidth, const float * colors)
Draws a list of individual lines, each specified by a succeeding pair of points.
- Parameters
- stride -
- stride in bytes to next point, ie: nextpoint = (float*)((char*)ppoints+stride)
- Return
- handle to plotted points, graph is removed when handle is destroyed (goes out of scope). This requires the user to always store the handle in a persistent variable if the plotted graphics are to remain on the viewer.
- Environment.drawlinestrip((Environment)arg1, (object)points, (float)linewidth[, (object)colors[, (int)drawstyle]]) → object :¶
OpenRAVE::GraphHandlePtr drawlinestrip(const float * ppoints, int numPoints, int stride, float fwidth, const float * colors)
Draws a series of connected lines with individual colors.
- Parameters
- stride -
- stride in bytes to next point, ie: nextpoint = (float*)((char*)ppoints+stride)
- Return
- handle to plotted points, graph is removed when handle is destroyed (goes out of scope). This requires the user to always store the handle in a persistent variable if the plotted graphics are to remain on the viewer.
- Environment.drawplane((Environment)arg1, (object)transform, (object)extents, (object)texture) → object :¶
OpenRAVE::GraphHandlePtr drawplane(const RaveTransform < float > & tplane, const RaveVector< float > & vextents, const boost::multi_array< float, 3 > & vtexture)
Draws a textured plane.
- Parameters
- tplane -
- describes the center of the plane. the zaxis of this coordinate is the normal of the plane
- vextents -
- the extents of the plane along the x and y directions (z is ignored)
- vtexture -
- a 3D array specifying height x width x color (the color dimension can be 1, 3, or 4 (for alpha blending))
- Return
- handle to plotted points, graph is removed when handle is destroyed (goes out of scope). This requires the user to always store the handle in a persistent variable if the plotted graphics are to remain on the viewer.
drawplane( (Environment)arg1, (object)transform, (object)extents, (object)texture) -> object :
OpenRAVE::GraphHandlePtr drawplane(const RaveTransform < float > & tplane, const RaveVector< float > & vextents, const boost::multi_array< float, 3 > & vtexture)
Draws a textured plane.
- Parameters
- tplane -
- describes the center of the plane. the zaxis of this coordinate is the normal of the plane
- vextents -
- the extents of the plane along the x and y directions (z is ignored)
- vtexture -
- a 3D array specifying height x width x color (the color dimension can be 1, 3, or 4 (for alpha blending))
- Return
- handle to plotted points, graph is removed when handle is destroyed (goes out of scope). This requires the user to always store the handle in a persistent variable if the plotted graphics are to remain on the viewer.
- Environment.drawtrimesh((Environment)arg1, (object)points[, (object)indices[, (object)colors]]) → object :¶
OpenRAVE::GraphHandlePtr drawtrimesh(const float * ppoints, int stride, const int * pIndices, int numTriangles, const boost::multi_array< float, 2 > & colors)
Draws a triangle mesh, each vertices of each triangle should be counter-clockwise.
- Parameters
- ppoints -
- array of 3D points
- stride -
- stride in bytes to next point, ie: nextpoint = (float*)((char*)ppoints+stride)
- pIndices -
- If not NULL, zero-based indices into the points for every triangle. pIndices should be of size numTriangles. If pIndices is NULL, ppoints is assumed to contain numTriangles*3 points and triangles will be rendered in list order.
- color -
- The color of the triangle. The last component of the color is used for alpha blending
- Return
- handle to plotted points, graph is removed when handle is destroyed (goes out of scope). This requires the user to always store the handle in a persistent variable if the plotted graphics are to remain on the viewer.
- Environment.plot3((Environment)arg1, (object)points, (float)pointsize[, (object)colors[, (int)drawstyle]]) → object¶
- class openravepy.openravepy_int.ErrorCode¶
Bases: Boost.Python.enum
OpenRAVEErrorCode
OpenRAVE error codes- Assert = openravepy.openravepy_int.ErrorCode.Assert¶
- CommandNotSupported = openravepy.openravepy_int.ErrorCode.CommandNotSupported¶
- EnvironmentNotLocked = openravepy.openravepy_int.ErrorCode.EnvironmentNotLocked¶
- Failed = openravepy.openravepy_int.ErrorCode.Failed¶
- InconsistentConstraints = openravepy.openravepy_int.ErrorCode.InconsistentConstraints¶
- InvalidArguments = openravepy.openravepy_int.ErrorCode.InvalidArguments¶
- InvalidInterfaceHash = openravepy.openravepy_int.ErrorCode.InvalidInterfaceHash¶
- InvalidPlugin = openravepy.openravepy_int.ErrorCode.InvalidPlugin¶
- InvalidState = openravepy.openravepy_int.ErrorCode.InvalidState¶
- NotImplemented = openravepy.openravepy_int.ErrorCode.NotImplemented¶
- NotInitialized = openravepy.openravepy_int.ErrorCode.NotInitialized¶
- Timeout = openravepy.openravepy_int.ErrorCode.Timeout¶
- names = {'NotInitialized': openravepy.openravepy_int.ErrorCode.NotInitialized, 'EnvironmentNotLocked': openravepy.openravepy_int.ErrorCode.EnvironmentNotLocked, 'InvalidPlugin': openravepy.openravepy_int.ErrorCode.InvalidPlugin, 'CommandNotSupported': openravepy.openravepy_int.ErrorCode.CommandNotSupported, 'Assert': openravepy.openravepy_int.ErrorCode.Assert, 'Failed': openravepy.openravepy_int.ErrorCode.Failed, 'Timeout': openravepy.openravepy_int.ErrorCode.Timeout, 'InvalidState': openravepy.openravepy_int.ErrorCode.InvalidState, 'InvalidArguments': openravepy.openravepy_int.ErrorCode.InvalidArguments, 'InconsistentConstraints': openravepy.openravepy_int.ErrorCode.InconsistentConstraints, 'InvalidInterfaceHash': openravepy.openravepy_int.ErrorCode.InvalidInterfaceHash, 'NotImplemented': openravepy.openravepy_int.ErrorCode.NotImplemented}¶
- values = {0: openravepy.openravepy_int.ErrorCode.Failed, 1: openravepy.openravepy_int.ErrorCode.InvalidArguments, 2: openravepy.openravepy_int.ErrorCode.EnvironmentNotLocked, 3: openravepy.openravepy_int.ErrorCode.CommandNotSupported, 4: openravepy.openravepy_int.ErrorCode.Assert, 5: openravepy.openravepy_int.ErrorCode.InvalidPlugin, 6: openravepy.openravepy_int.ErrorCode.InvalidInterfaceHash, 7: openravepy.openravepy_int.ErrorCode.NotImplemented, 8: openravepy.openravepy_int.ErrorCode.InconsistentConstraints, 9: openravepy.openravepy_int.ErrorCode.NotInitialized, 10: openravepy.openravepy_int.ErrorCode.InvalidState, 11: openravepy.openravepy_int.ErrorCode.Timeout}¶
- class openravepy.openravepy_int.GeometryType¶
Bases: Boost.Python.enum
- Box = openravepy.openravepy_int.GeometryType.Box¶
- Cylinder = openravepy.openravepy_int.GeometryType.Cylinder¶
- None = openravepy.openravepy_int.GeometryType.None¶
- Sphere = openravepy.openravepy_int.GeometryType.Sphere¶
- Trimesh = openravepy.openravepy_int.GeometryType.Trimesh¶
- names = {'Box': openravepy.openravepy_int.GeometryType.Box, 'Sphere': openravepy.openravepy_int.GeometryType.Sphere, 'None': openravepy.openravepy_int.GeometryType.None, 'Cylinder': openravepy.openravepy_int.GeometryType.Cylinder, 'Trimesh': openravepy.openravepy_int.GeometryType.Trimesh}¶
- values = {0: openravepy.openravepy_int.GeometryType.None, 1: openravepy.openravepy_int.GeometryType.Box, 2: openravepy.openravepy_int.GeometryType.Sphere, 3: openravepy.openravepy_int.GeometryType.Cylinder, 4: openravepy.openravepy_int.GeometryType.Trimesh}¶
- class openravepy.openravepy_int.GraphHandle¶
Bases: Boost.Python.instance
Raises an exception This class cannot be instantiated from Python
- Close((GraphHandle)arg1) → None¶
- SetShow((GraphHandle)arg1, (bool)arg2) → None :¶
void SetShow(bool bshow)
Shows or hides the plot without destroying its resources.
- SetTransform((GraphHandle)arg1, (object)arg2) → None :¶
void SetTransform(const RaveTransform < float > & t)
Changes the underlying transformation of the plot.
- Parameters
- t -
- new transformation of the plot
- class openravepy.openravepy_int.IkFilterOptions¶
Bases: Boost.Python.enum
IkFilterOptions
Controls what information gets validated when searching for an inverse kinematics solution.- CheckEnvCollisions = openravepy.openravepy_int.IkFilterOptions.CheckEnvCollisions¶
- IgnoreCustomFilters = openravepy.openravepy_int.IkFilterOptions.IgnoreCustomFilters¶
- IgnoreEndEffectorCollisions = openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorCollisions¶
- IgnoreEndEffectorEnvCollisions = openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorEnvCollisions¶
- IgnoreEndEffectorSelfCollisions = openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorSelfCollisions¶
- IgnoreJointLimits = openravepy.openravepy_int.IkFilterOptions.IgnoreJointLimits¶
- IgnoreSelfCollisions = openravepy.openravepy_int.IkFilterOptions.IgnoreSelfCollisions¶
- names = {'IgnoreEndEffectorCollisions': openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorCollisions, 'IgnoreCustomFilters': openravepy.openravepy_int.IkFilterOptions.IgnoreCustomFilters, 'IgnoreSelfCollisions': openravepy.openravepy_int.IkFilterOptions.IgnoreSelfCollisions, 'IgnoreEndEffectorEnvCollisions': openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorEnvCollisions, 'CheckEnvCollisions': openravepy.openravepy_int.IkFilterOptions.CheckEnvCollisions, 'IgnoreEndEffectorSelfCollisions': openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorSelfCollisions, 'IgnoreJointLimits': openravepy.openravepy_int.IkFilterOptions.IgnoreJointLimits}¶
- values = {32: openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorSelfCollisions, 1: openravepy.openravepy_int.IkFilterOptions.CheckEnvCollisions, 2: openravepy.openravepy_int.IkFilterOptions.IgnoreSelfCollisions, 4: openravepy.openravepy_int.IkFilterOptions.IgnoreJointLimits, 8: openravepy.openravepy_int.IkFilterOptions.IgnoreCustomFilters, 16: openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorEnvCollisions}¶
- class openravepy.openravepy_int.IkParameterization¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
__init__( (object)arg1, (object)primitive, (IkParameterizationType)type) -> None
__init__( (object)arg1, (str)str) -> None
__init__( (object)arg1, (IkParameterization)ikparam) -> None
- ClearCustomValues((IkParameterization)arg1[, (str)name]) → int :¶
size_t ClearCustomValues(const std::string & name = std::string() )
clears custom data
- Parameters
- name -
- if name is empty, will clear all the data, otherwise will clear only the custom data with that name
- Return
- number of elements erased
- ComputeDistanceSqr((IkParameterization)arg1, (IkParameterization)arg2) → float :¶
dReal ComputeDistanceSqr(const IkParameterization & ikparam)
Computes the distance squared between two IK parmaeterizations.
- GetConfigurationSpecification((IkParameterization)arg1) → object :¶
- ConfigurationSpecification GetConfigurationSpecification(const std::string & interpolation = “” )
GetConfigurationSpecification( (IkParameterization)arg1, (object)type) -> object :
ConfigurationSpecification GetConfigurationSpecification(const std::string & interpolation = “” )
- GetConfigurationSpecificationFromType((IkParameterizationType)type[, (str)interpolation]) → object :¶
ConfigurationSpecification GetConfigurationSpecification(const std::string & interpolation = “” )
- GetCustomDataMap((IkParameterization)arg1) → object :¶
const std::map< std::string, std::vector< dReal > > & GetCustomDataMap()
returns a const reference of the custom data key/value pairs
- GetCustomValues((IkParameterization)arg1, (str)name) → object :¶
bool GetCustomValues(const std::string & name, std::vector< dReal > & values)
gets custom data if it exists, returns false if it doesn’t
- GetDOF((IkParameterization)arg1) → int :¶
int GetDOF()
Returns the minimum degree of freedoms required for the IK type. Does count custom data.GetDOF( (IkParameterization)arg1, (object)type) -> int :
int GetDOF()
Returns the minimum degree of freedoms required for the IK type. Does count custom data.
- GetDOFFromType((IkParameterizationType)type) → int :¶
int GetDOF()
Returns the minimum degree of freedoms required for the IK type. Does count custom data.
- GetDirection3D((IkParameterization)arg1) → object :¶
const Vector & GetDirection3D()
- GetLookat3D((IkParameterization)arg1) → object :¶
const Vector & GetLookat3D()
- GetNumberOfValues((IkParameterization)arg1) → int :¶
int GetNumberOfValues()
Returns the number of values used to represent the parameterization ( >= dof ). Does count custom data.GetNumberOfValues( (IkParameterization)arg1, (object)type) -> int :
int GetNumberOfValues()
Returns the number of values used to represent the parameterization ( >= dof ). Does count custom data.
- GetNumberOfValuesFromType((IkParameterizationType)type) → int :¶
int GetNumberOfValues()
Returns the number of values used to represent the parameterization ( >= dof ). Does count custom data.
- GetRay4D((IkParameterization)arg1) → Ray :¶
const RAY GetRay4D()
- GetRotation3D((IkParameterization)arg1) → object :¶
const Vector & GetRotation3D()
- GetTransform6D((IkParameterization)arg1) → object :¶
const Transform & GetTransform6D()
- GetTranslation3D((IkParameterization)arg1) → object :¶
const Vector & GetTranslation3D()
- GetTranslationDirection5D((IkParameterization)arg1) → Ray :¶
const RAY GetTranslationDirection5D()
- GetTranslationLocalGlobal6D((IkParameterization)arg1) → object :¶
std::pair< Vector , Vector > GetTranslationLocalGlobal6D()
- GetTranslationXAxisAngle4D((IkParameterization)arg1) → object :¶
std::pair< Vector , dReal > GetTranslationXAxisAngle4D()
- GetTranslationXAxisAngleZNorm4D((IkParameterization)arg1) → object :¶
std::pair< Vector , dReal > GetTranslationXAxisAngleZNorm4D()
- GetTranslationXY2D((IkParameterization)arg1) → object :¶
const Vector & GetTranslationXY2D()
- GetTranslationXYOrientation3D((IkParameterization)arg1) → object :¶
const Vector & GetTranslationXYOrientation3D()
- GetTranslationYAxisAngle4D((IkParameterization)arg1) → object :¶
std::pair< Vector , dReal > GetTranslationYAxisAngle4D()
- GetTranslationYAxisAngleXNorm4D((IkParameterization)arg1) → object :¶
std::pair< Vector , dReal > GetTranslationYAxisAngleXNorm4D()
- GetTranslationZAxisAngle4D((IkParameterization)arg1) → object :¶
std::pair< Vector , dReal > GetTranslationZAxisAngle4D()
- GetTranslationZAxisAngleYNorm4D((IkParameterization)arg1) → object :¶
std::pair< Vector , dReal > GetTranslationZAxisAngleYNorm4D()
- GetType((IkParameterization)arg1) → IkParameterizationType :¶
IkParameterizationType GetType()
- GetValues((IkParameterization)arg1) → object :¶
void GetValues(std::vector< dReal >::iterator itvalues)
fills the iterator with the serialized values of the ikparameterization.
The container the iterator points to needs to have GetNumberOfValues() available. Does not support custom data Don’t normalize quaternions since it could hold velocity data.
- MultiplyTransform((IkParameterization)arg1, (object)arg2) → None :¶
IkParameterization & MultiplyTransform(const Transform & t)
in-place left-transform into a new coordinate system. Equivalent to t * ikparam
- SetCustomValue((IkParameterization)arg1, (str)name, (float)value) → None :¶
void SetCustomValue(const std::string & name, dReal value)
sets named custom data in the ik parameterization (
- See
- SetCustomValues)
- SetCustomValues((IkParameterization)arg1, (str)name, (object)values) → None :¶
void SetCustomValues(const std::string & name, const std::vector< dReal > & values)
sets named custom data in the ik parameterization
- The custom data is serialized along with the rest of the parameters and can also be part of a configuration specification under the “ikparam_values” anotation. The custom data name can have meta-tags for the type of transformation the data undergos when MultiplyTransform is called. For example, if the user wants to have an extra 3 values that represent “direction”, then the direction has to be rotated along with all the data or coordinate systems can get lost. The anotations are specified by putting: somewhere in the string. The s can be: , , , If , the first value is expected to be the unique id of the ik type (GetType()&IKP_UniqueIdMask). The other values can be computed from IkParameterization::GetValuesParameters
- name -
- Describes the type of data, cannot contain spaces or new lines.
- values -
- the values representing the data Exceptions
- openrave_exception -
- throws if the name is invalid
- SetDirection3D((IkParameterization)arg1, (object)dir) → None :¶
void SetDirection3D(const Vector & dir)
- SetLookat3D((IkParameterization)arg1, (object)pos) → None :¶
void SetLookat3D(const Vector & trans)
- SetRay4D((IkParameterization)arg1, (Ray)quat) → None :¶
void SetRay4D(const RAY & ray)
- SetRotation3D((IkParameterization)arg1, (object)quat) → None :¶
void SetRotation3D(const Vector & quaternion)
- SetTransform6D((IkParameterization)arg1, (object)transform) → None :¶
void SetTransform6D(const Transform & t)
- SetTranslation3D((IkParameterization)arg1, (object)pos) → None :¶
void SetTranslation3D(const Vector & trans)
- SetTranslationDirection5D((IkParameterization)arg1, (Ray)quat) → None :¶
void SetTranslationDirection5D(const RAY & ray)
- SetTranslationLocalGlobal6D((IkParameterization)arg1, (object)localpos, (object)pos) → None :¶
void SetTranslationLocalGlobal6D(const Vector & localtrans, const Vector & trans)
- SetTranslationXAxisAngle4D((IkParameterization)arg1, (object)translation, (float)angle) → None :¶
void SetTranslationXAxisAngle4D(const Vector & trans, dReal angle)
- SetTranslationXAxisAngleZNorm4D((IkParameterization)arg1, (object)translation, (float)angle) → None :¶
void SetTranslationXAxisAngleZNorm4D(const Vector & trans, dReal angle)
- SetTranslationXY2D((IkParameterization)arg1, (object)pos) → None :¶
void SetTranslationXY2D(const Vector & trans)
- SetTranslationXYOrientation3D((IkParameterization)arg1, (object)posangle) → None :¶
void SetTranslationXYOrientation3D(const Vector & trans)
- SetTranslationYAxisAngle4D((IkParameterization)arg1, (object)translation, (float)angle) → None :¶
void SetTranslationYAxisAngle4D(const Vector & trans, dReal angle)
- SetTranslationYAxisAngleXNorm4D((IkParameterization)arg1, (object)translation, (float)angle) → None :¶
void SetTranslationYAxisAngleXNorm4D(const Vector & trans, dReal angle)
- SetTranslationZAxisAngle4D((IkParameterization)arg1, (object)translation, (float)angle) → None :¶
void SetTranslationZAxisAngle4D(const Vector & trans, dReal angle)
- SetTranslationZAxisAngleYNorm4D((IkParameterization)arg1, (object)translation, (float)angle) → None :¶
void SetTranslationZAxisAngleYNorm4D(const Vector & trans, dReal angle)
- SetValues((IkParameterization)arg1, (object)values, (IkParameterizationType)type) → None :¶
void SetValues(std::vector< dReal >::const_iterator itvalues, IkParameterizationType iktype)
sets a serialized set of values for the IkParameterization
Function does not handle custom data. Don’t normalize quaternions since it could hold velocity data.
- Transform((IkParameterization)arg1, (object)arg2) → object :¶
Returns a new parameterization with transformed by the transformation T (T * ik)
- Type¶
alias of IkParameterizationType
- class openravepy.openravepy_int.IkParameterizationType¶
Bases: Boost.Python.enum
IkParameterizationType
The types of inverse kinematics parameterizations supported.
The minimum degree of freedoms required is set in the upper 4 bits of each type. The number of values used to represent the parameterization ( >= dof ) is the next 4 bits. The lower bits contain a unique id of the type.
- CustomDataBit = openravepy.openravepy_int.IkParameterizationType.CustomDataBit¶
- Direction3D = openravepy.openravepy_int.IkParameterizationType.Direction3D¶
- Direction3DVelocity = openravepy.openravepy_int.IkParameterizationType.Direction3DVelocity¶
- Lookat3D = openravepy.openravepy_int.IkParameterizationType.Lookat3D¶
- Lookat3DVelocity = openravepy.openravepy_int.IkParameterizationType.Lookat3DVelocity¶
- Ray4D = openravepy.openravepy_int.IkParameterizationType.Ray4D¶
- Ray4DVelocity = openravepy.openravepy_int.IkParameterizationType.Ray4DVelocity¶
- Rotation3D = openravepy.openravepy_int.IkParameterizationType.Rotation3D¶
- Rotation3DVelocity = openravepy.openravepy_int.IkParameterizationType.Rotation3DVelocity¶
- Transform6D = openravepy.openravepy_int.IkParameterizationType.Transform6D¶
- Transform6DVelocity = openravepy.openravepy_int.IkParameterizationType.Transform6DVelocity¶
- Translation3D = openravepy.openravepy_int.IkParameterizationType.Translation3D¶
- Translation3DVelocity = openravepy.openravepy_int.IkParameterizationType.Translation3DVelocity¶
- TranslationDirection5D = openravepy.openravepy_int.IkParameterizationType.TranslationDirection5D¶
- TranslationDirection5DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationDirection5DVelocity¶
- TranslationLocalGlobal6D = openravepy.openravepy_int.IkParameterizationType.TranslationLocalGlobal6D¶
- TranslationLocalGlobal6DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationLocalGlobal6DVelocity¶
- TranslationXAxisAngle4D = openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngle4D¶
- TranslationXAxisAngle4DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngle4DVelocity¶
- TranslationXAxisAngleZNorm4D = openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngleZNorm4D¶
- TranslationXAxisAngleZNorm4DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngleZNorm4DVelocity¶
- TranslationXY2D = openravepy.openravepy_int.IkParameterizationType.TranslationXY2D¶
- TranslationXY2DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationXY2DVelocity¶
- TranslationXYOrientation3D = openravepy.openravepy_int.IkParameterizationType.TranslationXYOrientation3D¶
- TranslationXYOrientation3DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationXYOrientation3DVelocity¶
- TranslationYAxisAngle4D = openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngle4D¶
- TranslationYAxisAngle4DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngle4DVelocity¶
- TranslationYAxisAngleXNorm4D = openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngleXNorm4D¶
- TranslationYAxisAngleXNorm4DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngleXNorm4DVelocity¶
- TranslationZAxisAngle4D = openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngle4D¶
- TranslationZAxisAngle4DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngle4DVelocity¶
- TranslationZAxisAngleYNorm4D = openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngleYNorm4D¶
- TranslationZAxisAngleYNorm4DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngleYNorm4DVelocity¶
- UniqueIdMask = openravepy.openravepy_int.IkParameterizationType.UniqueIdMask¶
- VelocityDataBit = openravepy.openravepy_int.IkParameterizationType.VelocityDataBit¶
- names = {'Rotation3DVelocity': openravepy.openravepy_int.IkParameterizationType.Rotation3DVelocity, 'Ray4D': openravepy.openravepy_int.IkParameterizationType.Ray4D, 'TranslationXY2D': openravepy.openravepy_int.IkParameterizationType.TranslationXY2D, 'TranslationXAxisAngleZNorm4D': openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngleZNorm4D, 'TranslationXYOrientation3D': openravepy.openravepy_int.IkParameterizationType.TranslationXYOrientation3D, 'TranslationXY2DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationXY2DVelocity, 'TranslationYAxisAngleXNorm4D': openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngleXNorm4D, 'Translation3DVelocity': openravepy.openravepy_int.IkParameterizationType.Translation3DVelocity, 'Direction3D': openravepy.openravepy_int.IkParameterizationType.Direction3D, 'TranslationZAxisAngleYNorm4D': openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngleYNorm4D, 'VelocityDataBit': openravepy.openravepy_int.IkParameterizationType.VelocityDataBit, 'Lookat3DVelocity': openravepy.openravepy_int.IkParameterizationType.Lookat3DVelocity, 'Direction3DVelocity': openravepy.openravepy_int.IkParameterizationType.Direction3DVelocity, 'CustomDataBit': openravepy.openravepy_int.IkParameterizationType.CustomDataBit, 'TranslationYAxisAngle4DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngle4DVelocity, 'TranslationYAxisAngle4D': openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngle4D, 'Transform6DVelocity': openravepy.openravepy_int.IkParameterizationType.Transform6DVelocity, 'TranslationYAxisAngleXNorm4DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngleXNorm4DVelocity, 'TranslationDirection5DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationDirection5DVelocity, 'Lookat3D': openravepy.openravepy_int.IkParameterizationType.Lookat3D, 'TranslationXAxisAngleZNorm4DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngleZNorm4DVelocity, 'Rotation3D': openravepy.openravepy_int.IkParameterizationType.Rotation3D, 'TranslationDirection5D': openravepy.openravepy_int.IkParameterizationType.TranslationDirection5D, 'Ray4DVelocity': openravepy.openravepy_int.IkParameterizationType.Ray4DVelocity, 'Transform6D': openravepy.openravepy_int.IkParameterizationType.Transform6D, 'TranslationXYOrientation3DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationXYOrientation3DVelocity, 'TranslationXAxisAngle4D': openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngle4D, 'TranslationZAxisAngle4D': openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngle4D, 'Translation3D': openravepy.openravepy_int.IkParameterizationType.Translation3D, 'TranslationZAxisAngle4DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngle4DVelocity, 'TranslationXAxisAngle4DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngle4DVelocity, 'TranslationZAxisAngleYNorm4DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngleYNorm4DVelocity, 'TranslationLocalGlobal6DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationLocalGlobal6DVelocity, 'UniqueIdMask': openravepy.openravepy_int.IkParameterizationType.UniqueIdMask, 'TranslationLocalGlobal6D': openravepy.openravepy_int.IkParameterizationType.TranslationLocalGlobal6D}¶
- values = {32768: openravepy.openravepy_int.IkParameterizationType.VelocityDataBit, 1728053249: openravepy.openravepy_int.IkParameterizationType.Transform6D, 872415234: openravepy.openravepy_int.IkParameterizationType.Rotation3D, 855638019: openravepy.openravepy_int.IkParameterizationType.Translation3D, 587202564: openravepy.openravepy_int.IkParameterizationType.Direction3D, 1174405125: openravepy.openravepy_int.IkParameterizationType.Ray4D, 587202566: openravepy.openravepy_int.IkParameterizationType.Lookat3D, 1442840583: openravepy.openravepy_int.IkParameterizationType.TranslationDirection5D, 570425352: openravepy.openravepy_int.IkParameterizationType.TranslationXY2D, 855638025: openravepy.openravepy_int.IkParameterizationType.TranslationXYOrientation3D, 905969674: openravepy.openravepy_int.IkParameterizationType.TranslationLocalGlobal6D, 1140850699: openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngle4D, 1140850700: openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngle4D, 1140850701: openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngle4D, 1140850702: openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngleZNorm4D, 1140850703: openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngleXNorm4D, 1140850704: openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngleYNorm4D, 855670787: openravepy.openravepy_int.IkParameterizationType.Translation3DVelocity, 587235332: openravepy.openravepy_int.IkParameterizationType.Direction3DVelocity, 1174437893: openravepy.openravepy_int.IkParameterizationType.Ray4DVelocity, 1728086017: openravepy.openravepy_int.IkParameterizationType.Transform6DVelocity, 587235334: openravepy.openravepy_int.IkParameterizationType.Lookat3DVelocity, 1442873351: openravepy.openravepy_int.IkParameterizationType.TranslationDirection5DVelocity, 570458120: openravepy.openravepy_int.IkParameterizationType.TranslationXY2DVelocity, 855670793: openravepy.openravepy_int.IkParameterizationType.TranslationXYOrientation3DVelocity, 906002442: openravepy.openravepy_int.IkParameterizationType.TranslationLocalGlobal6DVelocity, 872448002: openravepy.openravepy_int.IkParameterizationType.Rotation3DVelocity, 1140883467: openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngle4DVelocity, 1140883468: openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngle4DVelocity, 1140883469: openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngle4DVelocity, 1140883470: openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngleZNorm4DVelocity, 1140883471: openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngleXNorm4DVelocity, 65536: openravepy.openravepy_int.IkParameterizationType.CustomDataBit, 1140883472: openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngleYNorm4DVelocity, 65535: openravepy.openravepy_int.IkParameterizationType.UniqueIdMask}¶
- class openravepy.openravepy_int.IkReturn¶
Bases: Boost.Python.instance
__init__( (object)arg1, (IkReturnAction)action) -> None
- GetAction((IkReturn)arg1) → IkReturnAction :¶
Retuns IkReturn::_action
- GetMapData((IkReturn)arg1, (str)key) → object :¶
Indexes into the map and returns an array of numbers. If key doesn’t exist, returns None
- GetMapDataDict((IkReturn)arg1) → object :¶
Returns a dictionary copy for IkReturn::_mapdata
- GetSolution((IkReturn)arg1) → object :¶
Retuns IkReturn::_vsolution
- GetUserData((IkReturn)arg1) → object :¶
Retuns IkReturn::_userdata
- SetMapKeyValue((IkReturn)arg1, (str)arg2, (object)key, value) → None :¶
Adds key/value pair to IKReturn::_mapdata
- SetSolution((IkReturn)arg1, (object)solution) → None :¶
Set IKReturn::_vsolution
- SetUserData((IkReturn)arg1, (UserData)data) → None :¶
Set IKReturn::_userdata
- class openravepy.openravepy_int.IkReturnAction¶
Bases: Boost.Python.enum
IkReturnAction
Return value for the ik filter that can be optionally set on an ik solver.- Quit = openravepy.openravepy_int.IkReturnAction.Quit¶
- QuitEndEffectorCollision = openravepy.openravepy_int.IkReturnAction.QuitEndEffectorCollision¶
- Reject = openravepy.openravepy_int.IkReturnAction.Reject¶
- RejectCustomFilter = openravepy.openravepy_int.IkReturnAction.RejectCustomFilter¶
- RejectEnvCollision = openravepy.openravepy_int.IkReturnAction.RejectEnvCollision¶
- RejectJointLimits = openravepy.openravepy_int.IkReturnAction.RejectJointLimits¶
- RejectKinematics = openravepy.openravepy_int.IkReturnAction.RejectKinematics¶
- RejectKinematicsPrecision = openravepy.openravepy_int.IkReturnAction.RejectKinematicsPrecision¶
- RejectSelfCollision = openravepy.openravepy_int.IkReturnAction.RejectSelfCollision¶
- Success = openravepy.openravepy_int.IkReturnAction.Success¶
- names = {'Quit': openravepy.openravepy_int.IkReturnAction.Quit, 'RejectCustomFilter': openravepy.openravepy_int.IkReturnAction.RejectCustomFilter, 'Success': openravepy.openravepy_int.IkReturnAction.Success, 'Reject': openravepy.openravepy_int.IkReturnAction.Reject, 'QuitEndEffectorCollision': openravepy.openravepy_int.IkReturnAction.QuitEndEffectorCollision, 'RejectSelfCollision': openravepy.openravepy_int.IkReturnAction.RejectSelfCollision, 'RejectEnvCollision': openravepy.openravepy_int.IkReturnAction.RejectEnvCollision, 'RejectKinematicsPrecision': openravepy.openravepy_int.IkReturnAction.RejectKinematicsPrecision, 'RejectJointLimits': openravepy.openravepy_int.IkReturnAction.RejectJointLimits, 'RejectKinematics': openravepy.openravepy_int.IkReturnAction.RejectKinematics}¶
- values = {0: openravepy.openravepy_int.IkReturnAction.Success, 1: openravepy.openravepy_int.IkReturnAction.Reject, 2: openravepy.openravepy_int.IkReturnAction.Quit, 32769: openravepy.openravepy_int.IkReturnAction.RejectCustomFilter, 65: openravepy.openravepy_int.IkReturnAction.RejectEnvCollision, 33: openravepy.openravepy_int.IkReturnAction.RejectSelfCollision, 257: openravepy.openravepy_int.IkReturnAction.RejectJointLimits, 130: openravepy.openravepy_int.IkReturnAction.QuitEndEffectorCollision, 17: openravepy.openravepy_int.IkReturnAction.RejectKinematics, 513: openravepy.openravepy_int.IkReturnAction.RejectKinematicsPrecision}¶
- class openravepy.openravepy_int.IkSolver¶
Bases: openravepy.openravepy_int.Interface
Raises an exception This class cannot be instantiated from Python
- GetFreeParameters((IkSolver)arg1) → object :¶
bool GetFreeParameters(std::vector< dReal > & vFreeParameters)
gets the free parameters from the current robot configuration
- Parameters
- vFreeParameters -
- is filled with GetNumFreeParameters() parameters in [0,1] range
- Return
- true if succeeded
- GetNumFreeParameters((IkSolver)arg1) → int :¶
int GetNumFreeParameters()
Number of free parameters defining the null solution space.
Each parameter is always in the range of [0,1].
- RegisterCustomFilter((IkSolver)arg1, (int)priority, (object)callback) → object :¶
UserDataPtr RegisterCustomFilter(int priority, const IkFilterCallbackFn & filterfn)
Sets an ik solution filter that is called for every ik solution.
- Parameters
- priority -
- The priority of the filter that controls the order in which filters get called. Higher priority filters get called first. If not certain what to set, use 0.
- filterfn -
- an optional filter function to be called, see IkFilterCallbackFn. Multiple filters can be set at once, each filter will be called according to its priority; higher values get called first. The default implementation of IkSolverBase manages the filters internally. Users implementing their own IkSolverBase should call _CallFilters to run the internally managed filters.
- Return
- a managed handle to the filter. If this handle is released, then the fitler will be removed. Release operation is .
- Solve((IkSolver)arg1, (object)ikparam, (object)q0, (int)filteroptions) → IkReturn¶
Solve( (IkSolver)arg1, (object)ikparam, (object)q0, (object)freeparameters, (int)filteroptions) -> IkReturn
- SolveAll((IkSolver)arg1, (object)ikparam, (int)filteroptions) → object¶
SolveAll( (IkSolver)arg1, (object)ikparam, (object)freeparameters, (int)filteroptions) -> object
- Supports((IkSolver)arg1, (IkParameterizationType)iktype) → bool :¶
bool Supports(IkParameterizationType iktype)
returns true if the solver supports a particular ik parameterization as input.
- class openravepy.openravepy_int.Interface¶
Bases: Boost.Python.instance
Raises an exception This class cannot be instantiated from Python
- Clone((Interface)arg1, (Interface)ref, (int)cloningoptions) → None :¶
void Clone(InterfaceBaseConstPtr preference, int cloningoptions)
Clone the contents of an interface to the current interface.
- Parameters
- preference -
- the interface whose information to clone
- cloningoptions -
- mask of CloningOptions Exceptions
- openrave_exception -
- if command doesn’t succeed
- GetDescription((Interface)arg1) → object :¶
const std::string & GetDescription()
Documentation of the interface in reStructuredText format. See Documenting Interfaces.
- GetEnv((Interface)arg1) → Environment :¶
EnvironmentBasePtr GetEnv()
- Return
- the environment that this interface is attached to
- GetInterfaceType((Interface)arg1) → InterfaceType :¶
InterfaceType GetInterfaceType()
- GetPluginName((Interface)arg1) → str :¶
const std::string & GetPluginName()
set internally by RaveDatabase
- Return
- the pluginname this interface was loaded from
- GetReadableInterface((Interface)arg1, (str)arg2) → object¶
- GetReadableInterfaces((Interface)arg1) → object :¶
const READERSMAP & GetReadableInterfaces()
- GetUserData((Interface)arg1[, (str)key]) → object :¶
UserDataPtr GetUserData()
return the user custom data
- GetXMLId((Interface)arg1) → str :¶
const std::string & GetXMLId()
set internally by RaveDatabase
- Return
- the unique identifier that describes this class type, case is ignored should be the same id used to create the object
- RemoveUserData((Interface)arg1, (str)arg2) → bool¶
- SendCommand((Interface)arg1, (str)cmd[, (bool)releasegil]) → object :¶
bool SendCommand(std::ostream & os, std::istream & is)
Used to send special commands to the interface and receive output.
The command must be registered by RegisterCommand. A special command ‘ is always supported and provides a way for the user to query the current commands and the help string. The format of the returned help commands are in reStructuredText. The following commands are possible: Parameters
- is -
- the input stream containing the command
- os -
- the output stream containing the output Exceptions
- openrave_exception -
- Throw if the command is not supported.
- Return
- true if the command is successfully processed, otherwise false. The calling conventions between C++ and Python differ a little.
In C++ the syntax is:
success = SendCommand(OUT, IN)
In python, the syntax is:
OUT = SendCommand(IN,releasegil) success = OUT is not None
The releasegil parameter controls whether the python Global Interpreter Lock should be released when executing this code. For calls that take a long time and if there are many threads running called from different python threads, releasing the GIL could speed up things a lot. Please keep in mind that releasing and re-acquiring the GIL also takes computation time.
- SetDescription((Interface)arg1, (str)arg2) → None :¶
void SetDescription(const std::string & description)
- SetReadableInterface((Interface)arg1, (str)xmltag, (object)xmlreadable) → None :¶
XMLReadablePtr SetReadableInterface(const std::string & xmltag, XMLReadablePtr readable)
set a new readable interface and return the previously set interface if it exists
- SetUserData((Interface)arg1, (UserData)data) → None :¶
void SetUserData(UserDataPtr data)
set user dataSetUserData( (Interface)arg1, (object)data) -> None :
void SetUserData(UserDataPtr data)
set user dataSetUserData( (Interface)arg1, (str)key, (UserData)data) -> None :
void SetUserData(UserDataPtr data)
set user dataSetUserData( (Interface)arg1, (str)key, (object)data) -> None :
void SetUserData(UserDataPtr data)
set user data
- class openravepy.openravepy_int.InterfaceBase¶
Bases: Boost.Python.instance
Raises an exception This class cannot be instantiated from Python
- class openravepy.openravepy_int.InterfaceType¶
Bases: Boost.Python.enum
- collisionchecker = openravepy.openravepy_int.InterfaceType.collisionchecker¶
- controller = openravepy.openravepy_int.InterfaceType.controller¶
- iksolver = openravepy.openravepy_int.InterfaceType.iksolver¶
- kinbody = openravepy.openravepy_int.InterfaceType.kinbody¶
- module = openravepy.openravepy_int.InterfaceType.module¶
- names = {'planner': openravepy.openravepy_int.InterfaceType.planner, 'kinbody': openravepy.openravepy_int.InterfaceType.kinbody, 'physicsengine': openravepy.openravepy_int.InterfaceType.physicsengine, 'sensorsystem': openravepy.openravepy_int.InterfaceType.sensorsystem, 'spacesampler': openravepy.openravepy_int.InterfaceType.spacesampler, 'robot': openravepy.openravepy_int.InterfaceType.robot, 'module': openravepy.openravepy_int.InterfaceType.module, 'collisionchecker': openravepy.openravepy_int.InterfaceType.collisionchecker, 'viewer': openravepy.openravepy_int.InterfaceType.viewer, 'controller': openravepy.openravepy_int.InterfaceType.controller, 'probleminstance': openravepy.openravepy_int.InterfaceType.probleminstance, 'trajectory': openravepy.openravepy_int.InterfaceType.trajectory, 'iksolver': openravepy.openravepy_int.InterfaceType.iksolver, 'sensor': openravepy.openravepy_int.InterfaceType.sensor}¶
- physicsengine = openravepy.openravepy_int.InterfaceType.physicsengine¶
- planner = openravepy.openravepy_int.InterfaceType.planner¶
- probleminstance = openravepy.openravepy_int.InterfaceType.probleminstance¶
- robot = openravepy.openravepy_int.InterfaceType.robot¶
- sensor = openravepy.openravepy_int.InterfaceType.sensor¶
- sensorsystem = openravepy.openravepy_int.InterfaceType.sensorsystem¶
- spacesampler = openravepy.openravepy_int.InterfaceType.spacesampler¶
- trajectory = openravepy.openravepy_int.InterfaceType.trajectory¶
- values = {1: openravepy.openravepy_int.InterfaceType.planner, 2: openravepy.openravepy_int.InterfaceType.robot, 3: openravepy.openravepy_int.InterfaceType.sensorsystem, 4: openravepy.openravepy_int.InterfaceType.controller, 5: openravepy.openravepy_int.InterfaceType.module, 6: openravepy.openravepy_int.InterfaceType.iksolver, 7: openravepy.openravepy_int.InterfaceType.kinbody, 8: openravepy.openravepy_int.InterfaceType.physicsengine, 9: openravepy.openravepy_int.InterfaceType.sensor, 10: openravepy.openravepy_int.InterfaceType.collisionchecker, 11: openravepy.openravepy_int.InterfaceType.trajectory, 12: openravepy.openravepy_int.InterfaceType.viewer, 13: openravepy.openravepy_int.InterfaceType.spacesampler}¶
- viewer = openravepy.openravepy_int.InterfaceType.viewer¶
- class openravepy.openravepy_int.Interval¶
Bases: Boost.Python.enum
IntervalType
Specifies the boundary conditions of intervals for sampling.- Closed = openravepy.openravepy_int.Interval.Closed¶
- Open = openravepy.openravepy_int.Interval.Open¶
- OpenEnd = openravepy.openravepy_int.Interval.OpenEnd¶
- OpenStart = openravepy.openravepy_int.Interval.OpenStart¶
- names = {'OpenEnd': openravepy.openravepy_int.Interval.OpenEnd, 'Open': openravepy.openravepy_int.Interval.Open, 'OpenStart': openravepy.openravepy_int.Interval.OpenStart, 'Closed': openravepy.openravepy_int.Interval.Closed}¶
- values = {0: openravepy.openravepy_int.Interval.Open, 1: openravepy.openravepy_int.Interval.OpenStart, 2: openravepy.openravepy_int.Interval.OpenEnd, 3: openravepy.openravepy_int.Interval.Closed}¶
- class openravepy.openravepy_int.KinBody¶
Bases: openravepy.openravepy_int.Interface
Raises an exception This class cannot be instantiated from Python
- class AdjacentOptions¶
Bases: Boost.Python.enum
AdjacentOptions
specifies the type of adjacent link information to receive- ActiveDOFs = openravepy.openravepy_int.AdjacentOptions.ActiveDOFs¶
- Enabled = openravepy.openravepy_int.AdjacentOptions.Enabled¶
- names = {'ActiveDOFs': openravepy.openravepy_int.AdjacentOptions.ActiveDOFs, 'Enabled': openravepy.openravepy_int.AdjacentOptions.Enabled}¶
- values = {1: openravepy.openravepy_int.AdjacentOptions.Enabled, 2: openravepy.openravepy_int.AdjacentOptions.ActiveDOFs}¶
- KinBody.CalculateAngularVelocityJacobian((KinBody)arg1, (int)linkindex) → object :¶
void CalculateAngularVelocityJacobian(int linkindex, std::vector< dReal > & jacobian)
Computes the angular velocity jacobian of a specified link about the axes of world coordinates.
- KinBody.CalculateJacobian((KinBody)arg1, (int)linkindex, (object)position) → object :¶
void CalculateJacobian(int linkindex, const Vector & position, std::vector< dReal > & jacobian)
calls std::vector version of ComputeJacobian internally
- KinBody.CalculateRotationJacobian((KinBody)arg1, (int)linkindex, (object)quat) → object :¶
void CalculateRotationJacobian(int linkindex, const Vector & quat, std::vector< dReal > & jacobian)
Computes the rotational jacobian as a quaternion with respect to an initial rotation.
- Parameters
- linkindex -
- of the link that the rotation is attached to
- qInitialRot -
- the rotation in world space whose derivative to take from.
- jacobian -
- 4xDOF matrix
- class KinBody.CheckLimitsAction¶
Bases: Boost.Python.enum
CheckLimitsAction
used for specifying the type of limit checking and the messages associated with it- CheckLimits = openravepy.openravepy_int.CheckLimitsAction.CheckLimits¶
- CheckLimitsSilent = openravepy.openravepy_int.CheckLimitsAction.CheckLimitsSilent¶
- CheckLimitsThrow = openravepy.openravepy_int.CheckLimitsAction.CheckLimitsThrow¶
- Nothing = openravepy.openravepy_int.CheckLimitsAction.Nothing¶
- names = {'Nothing': openravepy.openravepy_int.CheckLimitsAction.Nothing, 'CheckLimitsThrow': openravepy.openravepy_int.CheckLimitsAction.CheckLimitsThrow, 'CheckLimitsSilent': openravepy.openravepy_int.CheckLimitsAction.CheckLimitsSilent, 'CheckLimits': openravepy.openravepy_int.CheckLimitsAction.CheckLimits}¶
- values = {0: openravepy.openravepy_int.CheckLimitsAction.Nothing, 1: openravepy.openravepy_int.CheckLimitsAction.CheckLimits, 2: openravepy.openravepy_int.CheckLimitsAction.CheckLimitsSilent, 3: openravepy.openravepy_int.CheckLimitsAction.CheckLimitsThrow}¶
- KinBody.CheckSelfCollision((KinBody)arg1) → bool :¶
bool CheckSelfCollision(CollisionReportPtr report = CollisionReportPtr () )
Check if body is self colliding. Links that are joined together are ignored.CheckSelfCollision( (KinBody)arg1, (CollisionReport)report) -> bool :
bool CheckSelfCollision(CollisionReportPtr report = CollisionReportPtr () )
Check if body is self colliding. Links that are joined together are ignored.
- KinBody.ComputeAABB((KinBody)arg1) → object :¶
AABB ComputeAABB()
Return an axis-aligned bounding box of the entire object in the world coordinate system.
- KinBody.ComputeHessianAxisAngle((KinBody)arg1, (int)linkindex[, (object)indices]) → object :¶
void ComputeHessianAxisAngle(int linkindex, std::vector< dReal > & hessian, const std::vector< int > & dofindices = std::vector< int >() )
Computes the DOFx3xDOF hessian of the rotation represented as angle-axis.
- Parameters
- linkindex -
- of the link that defines the frame the position is attached to /
- hessian -
- DOFx3xDOF matrix such that numpy.dot(dq,numpy.dot(hessian,dq)) is the expected second-order delta angle-axis /
- dofindices -
- the dof indices to compute the hessian for. If empty, will compute for all the dofs /
- KinBody.ComputeHessianTranslation((KinBody)arg1, (int)linkindex, (object)position[, (object)indices]) → object :¶
void ComputeHessianTranslation(int linkindex, const Vector & position, std::vector< dReal > & hessian, const std::vector< int > & dofindices = std::vector< int >() )
Computes the DOFx3xDOF hessian of the linear translation.
- Parameters
- linkindex -
- of the link that defines the frame the position is attached to /
- position -
- position in world space where to compute derivatives from. /
- hessian -
- DOFx3xDOF matrix such that numpy.dot(dq,numpy.dot(hessian,dq)) is the expected second-order delta translation /
- dofindices -
- the dof indices to compute the hessian for. If empty, will compute for all the dofs /
- KinBody.ComputeInverseDynamics((KinBody)arg1, (object)dofaccelerations[, (object)externalforcetorque[, (bool)returncomponents]]) → object :¶
Parameters: - returncomponents – If True will return three N-element arrays that represents the torque contributions to M, C, and G.
- externalforcetorque – A dictionary of link indices and a 6-element array of forces/torques in that order.
- KinBody.ComputeJacobianAxisAngle((KinBody)arg1, (int)linkindex[, (object)indices]) → object :¶
void ComputeJacobianAxisAngle(int linkindex, std::vector< dReal > & jacobian, const std::vector< int > & dofindices = std::vector< int >() )
Computes the angular velocity jacobian of a specified link about the axes of world coordinates.
- Parameters
- linkindex -
- of the link that the rotation is attached to
- vjacobian -
- 3xDOF matrix
- KinBody.ComputeJacobianTranslation((KinBody)arg1, (int)linkindex, (object)position[, (object)indices]) → object :¶
void ComputeJacobianTranslation(int linkindex, const Vector & position, std::vector< dReal > & jacobian, const std::vector< int > & dofindices = std::vector< int >() )
Computes the translation jacobian with respect to a world position.
- Parameters
- linkindex -
- of the link that defines the frame the position is attached to
- position -
- position in world space where to compute derivatives from.
- jacobian -
- 3xDOF matrix
- dofindices -
- the dof indices to compute the jacobian for. If empty, will compute for all the dofs Gets the jacobian with respect to a link by computing the partial differentials for all joints that in the path from the root node to GetLinks()[index] (doesn’t touch the rest of the values)
- KinBody.CreateKinBodyStateSaver((KinBody)arg1[, (object)options]) → StateRestoreContext :¶
Creates an object that can be entered using ‘with’ and returns a KinBodyStateSaver
- KinBody.DoesAffect((KinBody)arg1, (int)jointindex, (int)linkindex) → int :¶
int8_t DoesAffect(int jointindex, int linkindex)
Returns a nonzero value if the joint effects the link transformation.
- Parameters
- jointindex -
- index of the joint
- linkindex -
- index of the link In closed loops, all joints on all paths to the root link are counted as affecting the link. If a mimic joint affects the link, then all the joints used in the mimic joint’s computation affect the link. If negative, the partial derivative of the Jacobian should be negated.
- KinBody.Enable((KinBody)arg1, (bool)enable) → None :¶
void Enable(bool enable)
Enables or disables all the links.
- class KinBody.GeometryInfo¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
- KinBody.GetAdjacentLinks((KinBody)arg1) → object :¶
const std::set< int > & GetAdjacentLinks()
return all possible link pairs whose collisions are ignored.
- KinBody.GetAttached((KinBody)arg1) → object :¶
void GetAttached(std::set< KinBodyPtr > & setAttached)
Recursively get all attached bodies of this body, including this body.
- Parameters
- setAttached -
- fills with the attached bodies. If any bodies are already in setAttached, then ignores recursing on their attached bodies.
- KinBody.GetBodyTransformations((KinBody)arg1, (bool)arg2) → object :¶
void GetLinkTransformations(std::vector< Transform > & transforms)
get the transformations of all the links at once
- KinBody.GetChain((KinBody)arg1, (int)linkindex1, (int)linkindex2[, (bool)returnjoints]) → object :¶
bool GetChain(int linkindex1, int linkindex2, std::vector< JointPtr > & vjoints)
2つのリンクを繋ぐ関節の最短経路を計算する.
- Parameters
- linkindex1 -
- 始点リンクインデックス
- linkindex2 -
- 終点リンクインデックス
- vjoints 関節の経路 -
- 受動的な関節は,位置関係が固定されているリンクを見つけるために調べられている 受動的な関節も返される可能があるから,注意する必要があります.
- Return
- 経路が存在している場合,trueを返す. If returnjoints is false will return a list of links, otherwise will return a list of links (default is true)
- KinBody.GetClosedLoops((KinBody)arg1) → object :¶
const std::vector< std::vector< std::pair< LinkPtr , JointPtr > > > & GetClosedLoops()
Return the set of unique closed loops of the kinematics hierarchy.
Each loop is a set of link indices and joint indices. For example, a loop of link indices: [l_0,l_1,l_2] will consist of three joints connecting l_0 to l_1, l_1 to l_2, and l_2 to l_0. The first element in the pair is the link l_X, the second element in the joint connecting l_X to l_(X+1).
- KinBody.GetCollisionData((KinBody)arg1) → object :¶
UserDataPtr GetCollisionData()
SetCollisionData.
- KinBody.GetConfigurationSpecification((KinBody)arg1[, (str)interpolation]) → object :¶
ConfigurationSpecification GetConfigurationSpecification(const std::string & interpolation = “” )
return the configuration specification of the joint values and transform
Note that the return type is by-value, so should not be used in iteration
- KinBody.GetConfigurationSpecificationIndices((KinBody)arg1, (object)indices[, (str)interpolation]) → object :¶
ConfigurationSpecification GetConfigurationSpecificationIndices(const std::vector< int > & indices, const std::string & interpolation = “” )
return the configuration specification of the specified joint indices.
Note that the return type is by-value, so should not be used in iteration
- KinBody.GetConfigurationValues((KinBody)arg1) → object :¶
void GetConfigurationValues(std::vector< dReal > & v)
returns the configuration values as specified by GetConfigurationSpecification()
- KinBody.GetDOF((KinBody)arg1) → int :¶
int GetDOF()
Number controllable degrees of freedom of the body.
Only uses _vecjoints and last joint for computation, so can work before _ComputeInternalInformation is called.
- KinBody.GetDOFAccelerationLimits((KinBody)arg1) → object :¶
void GetDOFAccelerationLimits(std::vector< dReal > & maxaccelerations, const std::vector< int > & dofindices = std::vector< int >() )
Returns the max acceleration for each DOF.
- Parameters
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
GetDOFAccelerationLimits( (KinBody)arg1, (object)indices) -> object :
void GetDOFAccelerationLimits(std::vector< dReal > & maxaccelerations, const std::vector< int > & dofindices = std::vector< int >() )
Returns the max acceleration for each DOF.
- Parameters
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
- KinBody.GetDOFLimits((KinBody)arg1) → object :¶
void GetDOFLimits(std::vector< dReal > & lowerlimit, std::vector< dReal > & upperlimit, const std::vector< int > & dofindices = std::vector< int >() )
Returns all the joint limits as organized by the DOF indices.
- Parameters
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
GetDOFLimits( (KinBody)arg1, (object)indices) -> object :
void GetDOFLimits(std::vector< dReal > & lowerlimit, std::vector< dReal > & upperlimit, const std::vector< int > & dofindices = std::vector< int >() )
Returns all the joint limits as organized by the DOF indices.
- Parameters
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
- KinBody.GetDOFMaxAccel((KinBody)arg1) → object :¶
void GetDOFMaxAccel(std::vector< dReal > & v)
- KinBody.GetDOFMaxTorque((KinBody)arg1) → object :¶
void GetDOFMaxTorque(std::vector< dReal > & v)
- KinBody.GetDOFMaxVel((KinBody)arg1) → object :¶
void GetDOFMaxVel(std::vector< dReal > & v)
- KinBody.GetDOFResolutions((KinBody)arg1) → object :¶
void GetDOFResolutions(std::vector< dReal > & v, const std::vector< int > & dofindices = std::vector< int >() )
get the dof resolutions
- Parameters
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
GetDOFResolutions( (KinBody)arg1, (object)arg2) -> object :
void GetDOFResolutions(std::vector< dReal > & v, const std::vector< int > & dofindices = std::vector< int >() )
get the dof resolutions
- Parameters
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
- KinBody.GetDOFTorqueLimits((KinBody)arg1) → object :¶
void GetDOFTorqueLimits(std::vector< dReal > & maxaccelerations)
Returns the max torque for each DOF.GetDOFTorqueLimits( (KinBody)arg1, (object)indices) -> object :
void GetDOFTorqueLimits(std::vector< dReal > & maxaccelerations)
Returns the max torque for each DOF.
- KinBody.GetDOFValues((KinBody)arg1) → object :¶
void GetDOFValues(std::vector< dReal > & v, const std::vector< int > & dofindices = std::vector< int >() )
Returns all the joint values as organized by the DOF indices.
- Parameters
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
GetDOFValues( (KinBody)arg1, (object)indices) -> object :
void GetDOFValues(std::vector< dReal > & v, const std::vector< int > & dofindices = std::vector< int >() )
Returns all the joint values as organized by the DOF indices.
- Parameters
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
- KinBody.GetDOFVelocities((KinBody)arg1) → object :¶
void GetDOFVelocities(std::vector< dReal > & v, const std::vector< int > & dofindices = std::vector< int >() )
Returns all the joint velocities as organized by the DOF indices.
- Parameters
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
GetDOFVelocities( (KinBody)arg1, (object)indices) -> object :
void GetDOFVelocities(std::vector< dReal > & v, const std::vector< int > & dofindices = std::vector< int >() )
Returns all the joint velocities as organized by the DOF indices.
- Parameters
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
- KinBody.GetDOFVelocityLimits((KinBody)arg1) → object :¶
void GetDOFVelocityLimits(std::vector< dReal > & lowerlimit, std::vector< dReal > & upperlimit, const std::vector< int > & dofindices = std::vector< int >() )
Returns all the joint velocity limits as organized by the DOF indices.
- Parameters
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
GetDOFVelocityLimits( (KinBody)arg1, (object)indices) -> object :
void GetDOFVelocityLimits(std::vector< dReal > & lowerlimit, std::vector< dReal > & upperlimit, const std::vector< int > & dofindices = std::vector< int >() )
Returns all the joint velocity limits as organized by the DOF indices.
- Parameters
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
- KinBody.GetDOFWeights((KinBody)arg1) → object :¶
void GetDOFWeights(std::vector< dReal > & v, const std::vector< int > & dofindices = std::vector< int >() )
get dof weights
- Parameters
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
GetDOFWeights( (KinBody)arg1, (object)arg2) -> object :
void GetDOFWeights(std::vector< dReal > & v, const std::vector< int > & dofindices = std::vector< int >() )
get dof weights
- Parameters
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
- KinBody.GetDependencyOrderedJoints((KinBody)arg1) → object :¶
const std::vector< JointPtr > & GetDependencyOrderedJoints()
Returns the joints in hierarchical order starting at the base link.
In the case of closed loops, the joints are returned in the order closest to the root. All the joints affecting a particular joint’s transformation will always come before the joint in the list.
- KinBody.GetEnvironmentId((KinBody)arg1) → int :¶
int GetEnvironmentId()
return a unique id of the body used in the environment.
If object is not added to the environment, this will return 0. So checking if GetEnvironmentId() is 0 is a good way to check if object is present in the environment. This id will not be copied when cloning in order to respect another environment’s ids.
- KinBody.GetGuiData((KinBody)arg1) → object :¶
UserDataPtr GetViewerData()
- See
- SetViewerData
- KinBody.GetJoint((KinBody)arg1, (str)name) → object :¶
JointPtr GetJoint(const std::string & name)
Return a pointer to the joint with the given name. Search in the regular and passive joints.
- KinBody.GetJointFromDOFIndex((KinBody)arg1, (int)dofindex) → object :¶
JointPtr GetJointFromDOFIndex(int dofindex)
Returns the joint that covers the degree of freedom index.
Note that the mapping of joint structures is not the same as the values in GetJointValues since each joint can have more than one degree of freedom.
- KinBody.GetJointIndex((KinBody)arg1, (str)name) → int :¶
int GetJointIndex(const std::string & name)
Return the index of the joint with the given name, else -1.
- KinBody.GetJoints((KinBody)arg1) → object :¶
const std::vector< JointPtr > & GetJoints()
Returns the joints making up the controllable degrees of freedom of the body.GetJoints( (KinBody)arg1, (object)indices) -> object :
const std::vector< JointPtr > & GetJoints()
Returns the joints making up the controllable degrees of freedom of the body.
- KinBody.GetKinematicsGeometryHash((KinBody)arg1) → str :¶
const std::string & GetKinematicsGeometryHash()
A md5 hash unique to the particular kinematic and geometric structure of a KinBody.
This 32 byte string can be used to check if two bodies have the same kinematic structure and can be used to index into tables when looking for body-specific models. OpenRAVE stores all such models in the OPENRAVE_HOME directory (usually ~/.openrave), indexed by the particular robot/body hashes.
- Return
- md5 hash string of kinematics/geometry
- KinBody.GetLink((KinBody)arg1, (str)name) → object :¶
LinkPtr GetLink(const std::string & name)
return a pointer to the link with the given name
- KinBody.GetLinkAccelerations((KinBody)arg1, (object)arg2) → object :¶
void GetLinkAccelerations(const std::vector< dReal > & dofaccelerations, std::vector< std::pair< Vector , Vector > > & linkaccelerations)
Returns the linear and angular accelerations for each link given the dof accelerations.
- Parameters
- dofaccelerations -
- the accelerations of each of the DOF
- linkaccelerations -
- the linear and angular accelerations of link (in that order) Computes accelerations of the link frames with respect to the world coordinate system are returned. The base angular velocity is used when computing accelerations. The gravity vector from the physics engine is used as the accelerations for the base link and static links. The derivate is taken with respect to the world origin fixed in space (also known as spatial acceleration). The current angles and velocities set on the robot are used. Note that this function calls the internal _ComputeLinkAccelerations function, so for users that are interested in overriding it, override _ComputeLinkAccelerations
- KinBody.GetLinkTransformations((KinBody)arg1[, (bool)returndofbranches]) → object :¶
void GetLinkTransformations(std::vector< Transform > & transforms)
get the transformations of all the links at once
- KinBody.GetLinkVelocities((KinBody)arg1) → object :¶
void GetLinkVelocities(std::vector< std::pair< Vector , Vector > > & velocities)
Returns the linear and angular velocities for each link.
- Parameters
- velocities -
- The velocities of the link frames with respect to the world coordinate system are returned.
- KinBody.GetLinks((KinBody)arg1) → object :¶
const std::vector< LinkPtr > & GetLinks()
Returns all the rigid links of the body.GetLinks( (KinBody)arg1, (object)indices) -> object :
const std::vector< LinkPtr > & GetLinks()
Returns all the rigid links of the body.
- KinBody.GetManageData((KinBody)arg1) → object :¶
ManageDataPtr GetManageData()
- KinBody.GetName((KinBody)arg1) → object :¶
const std::string & GetName()
Unique name of the robot.
- KinBody.GetNonAdjacentLinks((KinBody)arg1) → object :¶
const std::set< int > & GetNonAdjacentLinks(int adjacentoptions = 0 )
return all possible link pairs that could get in collision.
- Parameters
- adjacentoptions -
- a bitmask of AdjacentOptions values
GetNonAdjacentLinks( (KinBody)arg1, (int)adjacentoptions) -> object :
const std::set< int > & GetNonAdjacentLinks(int adjacentoptions = 0 )
return all possible link pairs that could get in collision.
- Parameters
- adjacentoptions -
- a bitmask of AdjacentOptions values
- KinBody.GetPassiveJoints((KinBody)arg1) → object :¶
const std::vector< JointPtr > & GetPassiveJoints()
Returns the passive joints, order does not matter.
A passive joint is not directly controlled by the body’s degrees of freedom so it has no joint index and no dof index. Passive joints allows mimic joints to be hidden from the users. However, there are cases when passive joints are not mimic; for example, suspension mechanism on vehicles.
- KinBody.GetPhysicsData((KinBody)arg1) → object :¶
UserDataPtr GetPhysicsData()
- See
- SetPhysicsData
- KinBody.GetRigidlyAttachedLinks((KinBody)arg1, (int)linkindex) → object :¶
void GetRigidlyAttachedLinks(std::vector< boost::shared_ptr< Link > > & vattachedlinks)
Gets all the rigidly attached links to linkindex, also adds the link to the list.
- Parameters
- vattachedlinks -
- the array to insert all links attached to linkindex with the link itself.
- KinBody.GetTransform((KinBody)arg1) → object :¶
Transform GetTransform()
queries the transfromation of the first link of the body
- KinBody.GetURI((KinBody)arg1) → object :¶
const std::string & GetURI()
the URI used to load the interface (sometimes this is not possible if the definition lies inside an environment file).
- KinBody.GetUpdateStamp((KinBody)arg1) → int :¶
int GetUpdateStamp()
Return a unique id for every transformation state change of any link. Used to check if robot state has changed.
The stamp is used by the collision checkers, physics engines, or any other item that needs to keep track of any changes of the KinBody as it moves. Currently stamps monotonically increment for every transformation/joint angle change.
- KinBody.GetViewerData((KinBody)arg1) → object :¶
UserDataPtr GetViewerData()
- See
- SetViewerData
- KinBody.GetXMLFilename((KinBody)arg1) → object :¶
const std::string & GetURI()
the URI used to load the interface (sometimes this is not possible if the definition lies inside an environment file).
- KinBody.Init((KinBody)arg1, (object)linkinfos, (object)jointinfos) → bool¶
- KinBody.InitFromBoxes((KinBody)arg1, (object)boxes, (bool)draw) → bool :¶
bool InitFromBoxes(const std::vector< AABB > & boxes, bool visible)
Create a kinbody with one link composed of an array of aligned bounding boxes.
- Parameters
- boxes -
- the array of aligned bounding boxes that will comprise of the body
- visible -
- if true, the boxes will be rendered in the scene
boxes is a Nx6 array, first 3 columsn are position, last 3 are extents
- KinBody.InitFromGeometries((KinBody)arg1, (object)geometries) → bool :¶
bool InitFromGeometries(const std::list< KinBody::Link::GeometryInfo > & geometries)
Create a kinbody with one link composed of a list of geometries.
- Parameters
- geometries -
- a list of geometry infos to be initialized into new geometry objects, note that the geometry info data is copied
- visible -
- if true, will be rendered in the scene
- KinBody.InitFromSpheres((KinBody)arg1, (object)spherex, (bool)draw) → bool :¶
bool InitFromSpheres(const std::vector< Vector > & spheres, bool visible)
Create a kinbody with one link composed of an array of spheres.
- Parameters
- spheres -
- the XYZ position of the spheres with the W coordinate representing the individual radius
- visible -
- if true, the boxes will be rendered in the scene
- KinBody.InitFromTrimesh((KinBody)arg1, (object)trimesh, (bool)draw) → bool :¶
bool InitFromTrimesh(const Link::TRIMESH & trimesh, bool visible)
Create a kinbody with one link composed of a triangle mesh surface.
- Parameters
- trimesh -
- the triangle mesh
- visible -
- if true, will be rendered in the scene
- KinBody.IsAttached((KinBody)arg1, (KinBody)body) → bool :¶
bool IsAttached(KinBodyConstPtr body)
- Return
- true if two bodies should be considered as one during collision (ie one is grabbing the other)
- KinBody.IsDOFInChain((KinBody)arg1, (int)linkindex1, (int)linkindex2, (int)dofindex) → bool :¶
bool IsDOFInChain(int linkindex1, int linkindex2, int dofindex)
Returns true if the dof index affects the relative transformation between the two links.
- Parameters
- linkindex1 -
- the link index to start the search
- linkindex2 -
- the link index where the search ends The internal implementation uses KinBody::DoesAffect, therefore mimic indices are correctly handled.
- KinBody.IsEnabled((KinBody)arg1) → bool :¶
bool IsEnabled()
- Return
- true if any link of the KinBody is enabled
- KinBody.IsRobot((KinBody)arg1) → bool :¶
bool IsRobot()
Return true if this body is derived from RobotBase.
- KinBody.IsVisible((KinBody)arg1) → bool :¶
bool IsVisible()
- Return
- true if any link of the KinBody is visible.
- class KinBody.Joint¶
Bases: Boost.Python.instance
Raises an exception This class cannot be instantiated from Python
- AddTorque((Joint)arg1, (object)torques) → None :¶
void AddTorque(const std::vector< dReal > & torques)
Add effort (force or torque) to the joint.
- GetAccelerationLimits((Joint)arg1) → object :¶
void GetAccelerationLimits(std::vector< dReal > & vmax, bool bAppend = false )
Returns the max accelerations of the joint.
- Parameters
- the -
- max acceleration
- bAppend -
- if true will append to the end of the vector instead of erasing it
- GetAnchor((Joint)arg1) → object :¶
Vector GetAnchor()
The anchor of the joint in global coordinates.
- GetAxis((Joint)arg1[, (int)axis]) → object :¶
Vector GetAxis(int axis = 0 )
The axis of the joint in global coordinates.
- Parameters
- axis -
- the axis to get
- GetDOF((Joint)arg1) → int :¶
int GetDOF()
The degrees of freedom of the joint. Each joint supports a max of 3 degrees of freedom.
- GetDOFIndex((Joint)arg1) → int :¶
int GetDOFIndex()
Get the degree of freedom index in the body’s DOF array.
This does not index in KinBody::GetJoints() directly! In other words, KinBody::GetDOFValues()[GetDOFIndex()] == GetValues()[0]
- GetFirstAttached((Joint)arg1) → Link :¶
LinkPtr GetFirstAttached()
- GetFloatParameters((Joint)arg1[, (object)name[, (int)index]]) → object¶
- GetHierarchyChildLink((Joint)arg1) → Link :¶
LinkPtr GetHierarchyChildLink()
Return the child link whose transformation is computed by this joint’s values (either GetFirstAttached() or GetSecondAttached())
- GetHierarchyParentLink((Joint)arg1) → Link :¶
LinkPtr GetHierarchyParentLink()
Return the parent link which the joint measures its angle off from (either GetFirstAttached() or GetSecondAttached())
- GetInfo((Joint)arg1) → object¶
- GetIntParameters((Joint)arg1[, (object)name[, (int)index]]) → object¶
- GetInternalHierarchyAxis((Joint)arg1, (int)axis) → object :¶
Vector GetInternalHierarchyAxis(int axis = 0 )
The axis of the joint in local coordinates.
- GetInternalHierarchyLeftTransform((Joint)arg1) → object :¶
Transform GetInternalHierarchyLeftTransform()
Left multiply transform given the base body.
- GetInternalHierarchyRightTransform((Joint)arg1) → object :¶
Transform GetInternalHierarchyRightTransform()
Right multiply transform given the base body.
- GetJointIndex((Joint)arg1) → int :¶
int GetJointIndex()
Get the joint index into KinBody::GetJoints.
- GetLimits((Joint)arg1) → object :¶
void GetLimits(std::vector< dReal > & vLowerLimit, std::vector< dReal > & vUpperLimit, bool bAppend = false )
Get the limits of the joint.
- Parameters
- vLowerLimit -
- the lower limits
- vUpperLimit -
- the upper limits
- bAppend -
- if true will append to the end of the vector instead of erasing it
- GetMaxAccel((Joint)arg1[, (int)axis]) → float :¶
dReal GetMaxAccel(int iaxis = 0 )
- GetMaxTorque((Joint)arg1[, (int)axis]) → float :¶
dReal GetMaxTorque(int iaxis = 0 )
- GetMaxVel((Joint)arg1[, (int)axis]) → float :¶
dReal GetMaxVel(int iaxis = 0 )
- GetMimicDOFIndices((Joint)arg1[, (int)axis]) → object :¶
void GetMimicDOFIndices(std::vector< int > & vmimicdofs, int axis = 0 )
Returns the set of DOF indices that the computation of a joint axis depends on. Order is arbitrary.
- Exceptions
- openrave_exception -
- Throws an exception if the axis is not mimic. If the mimic joint uses the values of other mimic joints, then the dependent DOFs of that joint are also copied over. Therefore, the dof indices returned can be more than the actual variables used in the equation.
- GetMimicEquation((Joint)arg1[, (int)axis[, (int)type[, (str)format]]]) → str :¶
std::string GetMimicEquation(int axis = 0 , int type = 0 , const std::string & format = “” )
If the joint is mimic, returns the equation to compute its value.
- Parameters
- axis -
- the axis index
- type -
- 0 for position, 1 for velocity, 2 for acceleration.
- format -
- the format the equations are returned in. If empty or “fparser”, equation in fparser format. Also supports: “mathml”.
MathML:Set ‘format’ to “mathml”. The joint variables are specified with <csymbol>. If a targetted joint has more than one degree of freedom, then axis is suffixed with _%d. If ‘type’ is 1 or 2, the partial derivatives are outputted as consecutive <math></math> tags in the same order as MIMIC::_vdofformat
- GetName((Joint)arg1) → object :¶
const std::string & GetName()
The unique name of the joint.
- GetParent((Joint)arg1) → KinBody :¶
KinBodyPtr GetParent()
- GetResolution((Joint)arg1, (int)axis) → float :¶
dReal GetResolution(int iaxis = 0 )
The discretization of the joint used when line-collision checking.
The resolutions are set as large as possible such that the joint will not go through obstacles of determined size.
- GetResolutions((Joint)arg1) → object :¶
void GetResolutions(std::vector< dReal > & resolutions, bool bAppend = false )
gets all resolutions for the joint axes
- Parameters
- bAppend -
- if true will append to the end of the vector instead of erasing it
- GetSecondAttached((Joint)arg1) → Link :¶
LinkPtr GetSecondAttached()
- GetTorqueLimits((Joint)arg1) → object :¶
void GetTorqueLimits(std::vector< dReal > & vmax, bool bAppend = false )
Returns the max torques of the joint.
- Parameters
- the -
- max torque
- bAppend -
- if true will append to the end of the vector instead of erasing it
- GetType((Joint)arg1) → JointType :¶
JointType GetType()
- GetValue((Joint)arg1, (int)arg2) → float¶
- GetValues((Joint)arg1) → object :¶
void GetValues(std::vector< dReal > & values, bool bAppend = false )
Return all the joint values with the correct offsets applied.
- Parameters
- bAppend -
- if true will append to the end of the vector instead of erasing it
- Return
- degrees of freedom of the joint (even if pValues is NULL)
- GetVelocities((Joint)arg1) → object :¶
void GetVelocities(std::vector< dReal > & values, bool bAppend = false )
Gets the joint velocities.
- Parameters
- bAppend -
- if true will append to the end of the vector instead of erasing it
- Return
- the degrees of freedom of the joint (even if pValues is NULL)
- GetVelocityLimits((Joint)arg1) → object :¶
void GetVelocityLimits(std::vector< dReal > & vmax, bool bAppend = false )
Returns the max velocities of the joint.
- Parameters
- the -
- max velocity
- bAppend -
- if true will append to the end of the vector instead of erasing it
- GetWeight((Joint)arg1, (int)axis) → float :¶
dReal GetWeight(int axis = 0 )
The weight associated with a joint’s axis for computing a distance in the robot configuration space.
- GetWeights((Joint)arg1) → object :¶
void GetWeights(std::vector< dReal > & weights, bool bAppend = false )
gets all weights for the joint axes
- Parameters
- bAppend -
- if true will append to the end of the vector instead of erasing it
- GetWrapOffset((Joint)arg1[, (int)axis]) → float :¶
dReal GetWrapOffset(int iaxis = 0 )
Return internal offset parameter that determines the branch the angle centers on.
- Parameters
- iaxis -
- the axis to get the offset from Wrap offsets are needed for rotation joints since the range is limited to 2*pi. This allows the wrap offset to be set so the joint can function in [-pi+offset,pi+offset]..
- IsCircular((Joint)arg1, (int)arg2) → bool :¶
bool IsCircular(int iaxis)
Return true if joint axis has an identification at some of its lower and upper limits.
An identification of the lower and upper limits means that once the joint reaches its upper limits, it is also at its lower limit. The most common identification on revolute joints at -pi and pi. ‘circularity’ means the joint does not stop at limits. Although currently not developed, it could be possible to support identification for joints that are not revolute.
- IsMimic((Joint)arg1[, (int)axis]) → bool :¶
bool IsMimic(int axis = -1 )
Returns true if a particular axis of the joint is mimiced.
- Parameters
- axis -
- the axis to query. When -1 returns true if any of the axes have mimic joints
- IsPrismatic((Joint)arg1, (int)arg2) → bool :¶
bool IsPrismatic(int iaxis)
returns true if the axis describes a translation around an axis.
- Parameters
- iaxis -
- the axis of the joint to return the results for
- IsRevolute((Joint)arg1, (int)arg2) → bool :¶
bool IsRevolute(int iaxis)
returns true if the axis describes a rotation around an axis.
- Parameters
- iaxis -
- the axis of the joint to return the results for
- IsStatic((Joint)arg1) → bool :¶
bool IsStatic()
Return true if joint can be treated as a static binding (ie all limits are 0)
- SetAccelerationLimits((Joint)arg1, (object)maxlimits) → None :¶
void SetAccelerationLimits(const std::vector< dReal > & vmax)
- See
- GetAccelerationLimits
- SetFloatParameters((Joint)arg1, (str)arg2, (object)arg3) → None¶
- SetIntParameters((Joint)arg1, (str)arg2, (object)arg3) → None¶
- SetLimits((Joint)arg1, (object)lower, (object)upper) → None :¶
void SetLimits(const std::vector< dReal > & lower, const std::vector< dReal > & upper)
- See
- GetLimits
- SetMimicEquations((Joint)arg1, (int)axis, (str)poseq, (str)veleq, (str)acceleq) → None :¶
void SetMimicEquations(int axis, const std::string & poseq, const std::string & veleq, const std::string & acceleq = “” )
Sets the mimic properties of the joint.
- The equations can use the joint names directly in the equation, which represent the position of the joint. Any non-mimic joint part of KinBody::GetJoints() can be used in the computation of the values. If a joint has more than one degree of freedom, then suffix it ‘_’ and the axis index. For example universaljoint_0 * 10 + sin(universaljoint_1).See for a full description of the equation formats.The velocity and acceleration equations are specified in terms of partial derivatives, which means one expression needs to be specified per degree of freedom of used. In order to separate the expressions use “|name ...”. The name should immediately follow ‘|‘. For example:|universaljoint_0 10 |universaljoint_1 10*cos(universaljoint_1)If there is only one variable used in the position equation, then the equation can be specified directly without using “{}”.Parameters
- axis -
- the axis to set the properties for.
- poseq -
- Equation for joint’s position. If it is empty, the mimic properties are turned off for this joint.
- veleq -
- First-order partial derivatives of poseq with respect to all used DOFs. Only the variables used in poseq are allowed to be used. If poseq is not empty, this is required.
- acceleq -
- Second-order partial derivatives of poseq with respect to all used DOFs. Only the variables used in poseq are allowed to be used. Optional. Exceptions
- openrave_exception -
- Throws an exception if the mimic equation is invalid in any way.
- SetResolution((Joint)arg1, (float)resolution) → None :¶
void SetResolution(dReal resolution, int iaxis = 0 )
- SetTorqueLimits((Joint)arg1, (object)maxlimits) → None :¶
void SetTorqueLimits(const std::vector< dReal > & vmax)
- See
- GetTorqueLimits
- SetVelocityLimits((Joint)arg1, (object)maxlimits) → None :¶
void SetVelocityLimits(const std::vector< dReal > & vmax)
- See
- GetVelocityLimits
- SetWeights((Joint)arg1, (object)weights) → None :¶
void SetWeights(const std::vector< dReal > & weights)
- See
- GetWeight
- SetWrapOffset((Joint)arg1, (float)offset[, (int)axis]) → None :¶
void SetWrapOffset(dReal offset, int iaxis = 0 )
- See
- GetWrapOffset
- SubtractValue((Joint)arg1, (float)value0, (float)value1, (int)axis) → float :¶
dReal SubtractValue(dReal value1, dReal value2, int iaxis)
Returns the configuration difference value1-value2 for axis i.
Takes into account joint limits and wrapping of circular joints.
- SubtractValues((Joint)arg1, (object)values0, (object)values1) → object :¶
void SubtractValues(std::vector< dReal > & values1, const std::vector< dReal > & values2)
Computes the configuration difference values1-values2 and stores it in values1.
Takes into account joint limits and wrapping of circular joints.
- Type¶
alias of JointType
- UpdateAndGetInfo((Joint)arg1) → object¶
- UpdateInfo((Joint)arg1) → None¶
- class KinBody.JointInfo¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
- class KinBody.JointType¶
Bases: Boost.Python.enum
JointType
The type of joint movement.
Non-special joints that are combinations of revolution and prismatic joints. The first 4 bits specify the joint DOF, the next bits specify whether the joint is revolute (0) or prismatic (1). There can be also special joint types that are valid if the JointSpecialBit is set.For multi-dof joints, the order is transform(parentlink) * transform(axis0) * transform(axis1) ...
- Hinge = openravepy.openravepy_int.JointType.Hinge¶
- Hinge2 = openravepy.openravepy_int.JointType.Hinge2¶
- None = openravepy.openravepy_int.JointType.None¶
- PP = openravepy.openravepy_int.JointType.PP¶
- PR = openravepy.openravepy_int.JointType.PR¶
- Prismatic = openravepy.openravepy_int.JointType.Prismatic¶
- RP = openravepy.openravepy_int.JointType.RP¶
- RR = openravepy.openravepy_int.JointType.RR¶
- Revolute = openravepy.openravepy_int.JointType.Revolute¶
- Slider = openravepy.openravepy_int.JointType.Slider¶
- Spherical = openravepy.openravepy_int.JointType.Spherical¶
- Trajectory = openravepy.openravepy_int.JointType.Trajectory¶
- Universal = openravepy.openravepy_int.JointType.Universal¶
- names = {'PR': openravepy.openravepy_int.JointType.PR, 'Spherical': openravepy.openravepy_int.JointType.Spherical, 'None': openravepy.openravepy_int.JointType.None, 'RP': openravepy.openravepy_int.JointType.RP, 'RR': openravepy.openravepy_int.JointType.RR, 'Prismatic': openravepy.openravepy_int.JointType.Prismatic, 'Universal': openravepy.openravepy_int.JointType.Universal, 'Hinge2': openravepy.openravepy_int.JointType.Hinge2, 'PP': openravepy.openravepy_int.JointType.PP, 'Hinge': openravepy.openravepy_int.JointType.Hinge, 'Slider': openravepy.openravepy_int.JointType.Slider, 'Revolute': openravepy.openravepy_int.JointType.Revolute, 'Trajectory': openravepy.openravepy_int.JointType.Trajectory}¶
- values = {0: openravepy.openravepy_int.JointType.None, 1: openravepy.openravepy_int.JointType.Revolute, 2: openravepy.openravepy_int.JointType.RR, 50: openravepy.openravepy_int.JointType.PP, 2147483652: openravepy.openravepy_int.JointType.Trajectory, 2147483649: openravepy.openravepy_int.JointType.Universal, 2147483650: openravepy.openravepy_int.JointType.Hinge2, 34: openravepy.openravepy_int.JointType.PR, 17: openravepy.openravepy_int.JointType.Prismatic, 18: openravepy.openravepy_int.JointType.RP, 2147483651: openravepy.openravepy_int.JointType.Spherical}¶
- class KinBody.KinBodyStateSaver¶
Bases: Boost.Python.instance
__init__( (object)arg1, (KinBody)body) -> None
__init__( (object)arg1, (KinBody)body, (object)options) -> None
- GetBody((KinBodyStateSaver)arg1) → object¶
- Release((KinBodyStateSaver)arg1) → None¶
- Restore((KinBodyStateSaver)arg1[, (KinBody)body]) → None¶
- class KinBody.Link¶
Bases: Boost.Python.instance
Raises an exception This class cannot be instantiated from Python
- ComputeAABB((Link)arg1) → object :¶
AABB ComputeAABB()
Compute the aabb of all the geometries of the link in the world coordinate system.
- ComputeLocalAABB((Link)arg1, (object)arg2) → object¶
- Enable((Link)arg1, (bool)enable) → None :¶
void Enable(bool enable)
Enables a Link. An enabled link takes part in collision detection and physics simulations.
- GeomType¶
alias of GeometryType
- class Geometry¶
Bases: Boost.Python.instance
Raises an exception This class cannot be instantiated from Python
- ComputeAABB((Geometry)arg1, (object)transform) → object :¶
AABB ComputeAABB(const Transform & trans)
returns an axis aligned bounding box given that the geometry is transformed by trans
- GetAmbientColor((Geometry)arg1) → object :¶
const RaveVector< float > & GetAmbientColor()
- GetBoxExtents((Geometry)arg1) → object :¶
const Vector & GetBoxExtents()
- GetCollisionMesh((Geometry)arg1) → object :¶
const TRIMESH & GetCollisionMesh()
returns the local collision mesh
- GetCylinderHeight((Geometry)arg1) → float :¶
dReal GetCylinderHeight()
- GetCylinderRadius((Geometry)arg1) → float :¶
dReal GetCylinderRadius()
- GetDiffuseColor((Geometry)arg1) → object :¶
const RaveVector< float > & GetDiffuseColor()
- GetInfo((Geometry)arg1) → object¶
- GetRenderFilename((Geometry)arg1) → object :¶
const std::string & GetRenderFilename()
- GetRenderScale((Geometry)arg1) → object :¶
const Vector & GetRenderScale()
- GetSphereRadius((Geometry)arg1) → float :¶
dReal GetSphereRadius()
- GetTransform((Geometry)arg1) → object :¶
const Transform & GetTransform()
get local geometry transform
- GetTransparency((Geometry)arg1) → float :¶
float GetTransparency()
- GetType((Geometry)arg1) → GeometryType :¶
GeomType GetType()
- IsDraw((Geometry)arg1) → bool :¶
bool IsDraw()
- IsModifiable((Geometry)arg1) → bool :¶
bool IsModifiable()
- IsVisible((Geometry)arg1) → bool :¶
bool IsVisible()
- SetAmbientColor((Geometry)arg1, (object)color) → None :¶
void SetAmbientColor(const RaveVector< float > & color)
override ambient color of geometry material
- SetCollisionMesh((Geometry)arg1, (object)trimesh) → None :¶
void SetCollisionMesh(const TRIMESH & mesh)
sets a new collision mesh and notifies every registered callback about it
- SetDiffuseColor((Geometry)arg1, (object)color) → None :¶
void SetDiffuseColor(const RaveVector< float > & color)
override diffuse color of geometry material
- SetDraw((Geometry)arg1, (bool)draw) → None :¶
void SetDraw(bool bDraw)
- SetRenderFilename((Geometry)arg1, (str)color) → None :¶
void SetRenderFilename(const std::string & renderfilename)
sets a new render filename for the geometry. This does not change the collision
- SetTransparency((Geometry)arg1, (float)transparency) → None :¶
void SetTransparency(float f)
set transparency level (0 is opaque)
- Type¶
alias of GeometryType
- class KinBody.Link.GeometryInfo¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
- KinBody.Link.GetCOMOffset((Link)arg1) → object :¶
Vector GetCOMOffset()
- KinBody.Link.GetCollisionData((Link)arg1) → object :¶
const TRIMESH & GetCollisionData()
- KinBody.Link.GetFloatParameters((Link)arg1[, (object)name[, (int)index]]) → object¶
- KinBody.Link.GetGeometries((Link)arg1) → object :¶
const std::vector< GeometryPtr > & GetGeometries()
returns a list of all the geometry objects.
- KinBody.Link.GetGlobalCOM((Link)arg1) → object :¶
Vector GetGlobalCOM()
return center of mass of the link in the global coordinate system
- KinBody.Link.GetGlobalMassFrame((Link)arg1) → object :¶
Transform GetGlobalMassFrame()
return the mass frame in the global coordinate system that holds the center of mass and principal axes for inertia.
- KinBody.Link.GetIndex((Link)arg1) → int :¶
int GetIndex()
unique index into parent KinBody::GetLinks vector
- KinBody.Link.GetInfo((Link)arg1) → object¶
- KinBody.Link.GetIntParameters((Link)arg1[, (object)name[, (int)index]]) → object¶
- KinBody.Link.GetLocalCOM((Link)arg1) → object :¶
Vector GetLocalCOM()
return center of mass offset in the link’s local coordinate frame
- KinBody.Link.GetLocalInertia((Link)arg1) → object :¶
TransformMatrix GetLocalInertia()
return inertia in link’s local coordinate frame. The translation component is the the COM in the link’s frame.
- KinBody.Link.GetLocalMassFrame((Link)arg1) → object :¶
const Transform & GetLocalMassFrame()
return the mass frame in the link’s local coordinate system that holds the center of mass and principal axes for inertia.
- KinBody.Link.GetMass((Link)arg1) → float :¶
dReal GetMass()
- KinBody.Link.GetName((Link)arg1) → object :¶
const std::string & GetName()
- KinBody.Link.GetParent((Link)arg1) → object :¶
KinBodyPtr GetParent()
parent body that link belong to.
- KinBody.Link.GetParentLinks((Link)arg1) → object :¶
void GetParentLinks(std::vector< boost::shared_ptr< Link > > & vParentLinks)
Return all the direct parent links in the kinematics hierarchy of this link.
- Parameters
- filled -
- with the parent links A parent link is is immediately connected to this link by a joint and has a path to the root joint so that it is possible to compute this link’s transformation from its parent.
- KinBody.Link.GetPrincipalMomentsOfInertia((Link)arg1) → object :¶
const Vector & GetPrincipalMomentsOfInertia()
return the principal moments of inertia inside the mass frame
- KinBody.Link.GetRigidlyAttachedLinks((Link)arg1) → object :¶
void GetRigidlyAttachedLinks(std::vector< boost::shared_ptr< Link > > & vattachedlinks)
Gets all the rigidly attached links to linkindex, also adds the link to the list.
- Parameters
- vattachedlinks -
- the array to insert all links attached to linkindex with the link itself.
- KinBody.Link.GetTransform((Link)arg1) → object :¶
Transform GetTransform()
Return the current transformation of the link in the world coordinate system.
- KinBody.Link.GetVelocity((Link)arg1) → object :¶
void GetVelocity(Vector & linearvel, Vector & angularvel)
get the velocity of the link
- Parameters
- linearvel -
- the translational velocity
- angularvel -
- is the rotation axis * angular speed
- KinBody.Link.InitGeometries((Link)arg1, (object)geometries) → None¶
- KinBody.Link.IsEnabled((Link)arg1) → bool :¶
bool IsEnabled()
returns true if the link is enabled.
- See
- Enable
- KinBody.Link.IsParentLink((Link)arg1, (Link)arg2) → bool :¶
bool IsParentLink(boost::shared_ptr< Link const > plink)
Tests if a link is a direct parent.
- Parameters
- link -
- The link to test if it is one of the parents of this link.
- See
- GetParentLinks
- KinBody.Link.IsRigidlyAttached((Link)arg1, (Link)arg2) → bool :¶
bool IsRigidlyAttached(boost::shared_ptr< Link const > plink)
returns true if plink is rigidily attahced to this link.
- KinBody.Link.IsStatic((Link)arg1) → bool :¶
bool IsStatic()
Indicates a static body that does not move with respect to the root link.
Static should be used when an object has infinite mass and shouldn’t be affected by physics (including gravity). Collision still works.
- KinBody.Link.IsVisible((Link)arg1) → bool :¶
bool IsVisible()
- Return
- true if any geometry of the link is visible.
- KinBody.Link.SetFloatParameters((Link)arg1, (str)arg2, (object)arg3) → None¶
- KinBody.Link.SetForce((Link)arg1, (object)force, (object)pos, (bool)add) → None :¶
void SetForce(const Vector & force, const Vector & pos, bool add)
- Parameters
- force -
- the direction and magnitude of the force
- pos -
- in the world where the force is getting applied
- add -
- if true, force is added to previous forces, otherwise it is set adds an external force at pos (absolute coords)
- KinBody.Link.SetIntParameters((Link)arg1, (str)arg2, (object)arg3) → None¶
- KinBody.Link.SetLocalMassFrame((Link)arg1, (object)massframe) → None :¶
void SetLocalMassFrame(const Transform & massframe)
sets a new mass frame with respect to the link coordinate system
- KinBody.Link.SetMass((Link)arg1, (float)mass) → None :¶
void SetMass(dReal mass)
set a new mass
- KinBody.Link.SetPrincipalMomentsOfInertia((Link)arg1, (object)inertiamoments) → None :¶
void SetPrincipalMomentsOfInertia(const Vector & inertiamoments)
sets new principal moments of inertia (with respect to the mass frame)
- KinBody.Link.SetStatic((Link)arg1, (bool)static) → None :¶
void SetStatic(bool bStatic)
sets a link to be static.
Because this can affect the kinematics, it requires the body’s internal structures to be recomputed
- KinBody.Link.SetTorque((Link)arg1, (object)torque, (bool)add) → None :¶
void SetTorque(const Vector & torque, bool add)
- Parameters
- add -
- if true, torque is added to previous torques, otherwise it is set adds torque to a body (absolute coords)
- KinBody.Link.SetTransform((Link)arg1, (object)transform) → None :¶
void SetTransform(const Transform & transform)
Sets the transform of the link regardless of kinematics.
- Parameters
- t -
- the new transformation
- KinBody.Link.SetVelocity((Link)arg1, (object)arg2, (object)arg3) → None :¶
void SetVelocity(const Vector & linearvel, const Vector & angularvel)
- Parameters
- linearvel -
- the translational velocity
- angularvel -
- is the rotation axis * angular speed forces the velocity of the link
- KinBody.Link.SetVisible((Link)arg1, (bool)visible) → bool :¶
bool SetVisible(bool visible)
Sets all the geometries of the link as visible or non visible.
- Return
- true if changed
- KinBody.Link.UpdateAndGetInfo((Link)arg1) → object¶
- KinBody.Link.UpdateInfo((Link)arg1) → None¶
- class KinBody.LinkInfo¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
- class KinBody.ManageData¶
Bases: Boost.Python.instance
Raises an exception This class cannot be instantiated from Python
- GetData((ManageData)arg1) → object :¶
XMLReadableConstPtr GetData()
returns a pointer to the data used to initialize the BODY with AddKinBody. if psize is not NULL, will be filled with the size of the data in bytes This function will be used to restore bodies that were removed
- GetOffsetLink((ManageData)arg1) → Link :¶
KinBody::LinkPtr GetOffsetLink()
particular link that sensor system is tracking. All transformations describe this link.
- GetSystem((ManageData)arg1) → object :¶
SensorSystemBasePtr GetSystem()
- IsEnabled((ManageData)arg1) → bool :¶
bool IsEnabled()
true if should update openrave body
- IsLocked((ManageData)arg1) → bool :¶
bool IsLocked()
if true, the vision system should not destroy this object once it stops being present
- IsPresent((ManageData)arg1) → bool :¶
bool IsPresent()
true if the object is being updated by the system due to its presence in the real environment
- Lock((ManageData)arg1, (bool)dolock) → bool :¶
bool Lock(bool bDoLock)
set a lock on a particular body
- class KinBody.SaveParameters¶
Bases: Boost.Python.enum
SaveParameters
Parameters passed into the state savers to control what information gets saved.- ActiveDOF = openravepy.openravepy_int.SaveParameters.ActiveDOF¶
- ActiveManipulator = openravepy.openravepy_int.SaveParameters.ActiveManipulator¶
- GrabbedBodies = openravepy.openravepy_int.SaveParameters.GrabbedBodies¶
- JointMaxVelocityAndAcceleration = openravepy.openravepy_int.SaveParameters.JointMaxVelocityAndAcceleration¶
- LinkEnable = openravepy.openravepy_int.SaveParameters.LinkEnable¶
- LinkTransformation = openravepy.openravepy_int.SaveParameters.LinkTransformation¶
- names = {'LinkTransformation': openravepy.openravepy_int.SaveParameters.LinkTransformation, 'ActiveDOF': openravepy.openravepy_int.SaveParameters.ActiveDOF, 'JointMaxVelocityAndAcceleration': openravepy.openravepy_int.SaveParameters.JointMaxVelocityAndAcceleration, 'GrabbedBodies': openravepy.openravepy_int.SaveParameters.GrabbedBodies, 'LinkEnable': openravepy.openravepy_int.SaveParameters.LinkEnable, 'ActiveManipulator': openravepy.openravepy_int.SaveParameters.ActiveManipulator}¶
- values = {262144: openravepy.openravepy_int.SaveParameters.GrabbedBodies, 1: openravepy.openravepy_int.SaveParameters.LinkTransformation, 2: openravepy.openravepy_int.SaveParameters.LinkEnable, 65536: openravepy.openravepy_int.SaveParameters.ActiveDOF, 8: openravepy.openravepy_int.SaveParameters.JointMaxVelocityAndAcceleration, 131072: openravepy.openravepy_int.SaveParameters.ActiveManipulator}¶
- KinBody.SetBodyTransformations((KinBody)arg1, (object)arg2, (object)transforms) → None :¶
void SetLinkTransformations(const std::vector< Transform > & transforms)
sets the transformations of all the links at once
- KinBody.SetConfigurationValues((KinBody)arg1, (object)values[, (int)checklimits]) → None :¶
void SetConfigurationValues(std::vector< dReal >::const_iterator itvalues, uint32_t checklimits = CLA_CheckLimits )
sets joint values and transform of the body using configuration values as specified by GetConfigurationSpecification()
- Parameters
- itvalues -
- the iterator to the vector containing the dof values. Must have GetConfigurationSpecification().GetDOF() values!
- checklimits -
- one of CheckLimitsAction and will excplicitly check the joint limits before setting the values and clamp them.
- KinBody.SetDOFAccelerationLimits((KinBody)arg1, (object)limits) → None :¶
void SetDOFAccelerationLimits(const std::vector< dReal > & maxlimits)
- See
- GetDOFAccelerationLimits
- KinBody.SetDOFLimits((KinBody)arg1, (object)lower, (object)upper) → None :¶
void SetDOFLimits(const std::vector< dReal > & lower, const std::vector< dReal > & upper)
- See
- GetDOFLimits
- KinBody.SetDOFTorqueLimits((KinBody)arg1, (object)limits) → None :¶
void SetDOFTorqueLimits(const std::vector< dReal > & maxlimits)
- See
- GetDOFTorqueLimits
- KinBody.SetDOFTorques((KinBody)arg1, (object)torques, (bool)add) → None :¶
void SetDOFTorques(const std::vector< dReal > & torques, bool add)
Adds a torque to every joint.
- Parameters
- bAdd -
- if true, adds to previous torques, otherwise resets the torques on all bodies and starts from 0
- KinBody.SetDOFValues((KinBody)arg1, (object)values) → None :¶
void SetDOFValues(const std::vector< dReal > & values, uint32_t checklimits = CLA_CheckLimits , const std::vector< int > & dofindices = std::vector< int >() )
Sets the joint values of the robot.
- Parameters
- values -
- the values to set the joint angles (ordered by the dof indices)
- checklimits -
- one of CheckLimitsAction and will excplicitly check the joint limits before setting the values and clamp them.
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
SetDOFValues( (KinBody)arg1, (object)values, (object)dofindices) -> None :
void SetDOFValues(const std::vector< dReal > & values, uint32_t checklimits = CLA_CheckLimits , const std::vector< int > & dofindices = std::vector< int >() )
Sets the joint values of the robot.
- Parameters
- values -
- the values to set the joint angles (ordered by the dof indices)
- checklimits -
- one of CheckLimitsAction and will excplicitly check the joint limits before setting the values and clamp them.
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
SetDOFValues( (KinBody)arg1, (object)values, (object)dofindices, (int)checklimits) -> None :
void SetDOFValues(const std::vector< dReal > & values, uint32_t checklimits = CLA_CheckLimits , const std::vector< int > & dofindices = std::vector< int >() )
Sets the joint values of the robot.
- Parameters
- values -
- the values to set the joint angles (ordered by the dof indices)
- checklimits -
- one of CheckLimitsAction and will excplicitly check the joint limits before setting the values and clamp them.
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
- KinBody.SetDOFVelocities((KinBody)arg1, (object)dofvelocities) → None :¶
void SetDOFVelocities(const std::vector< dReal > & dofvelocities, uint32_t checklimits = CLA_CheckLimits )
Sets the velocity of the joints.
- Parameters
- dofvelocities -
- velocities of each of the degrees of freeom
- checklimits -
- if >0, will excplicitly check the joint velocity limits before setting the values and clamp them. If == 1, then will warn if the limits are overboard, if == 2, then will not warn (used for code that knows it’s giving bad values) Copies the current velocity of the base link and calls SetDOFVelocities(linearvel,angularvel,vDOFVelocities)
SetDOFVelocities( (KinBody)arg1, (object)dofvelocities, (object)linear, (object)angular) -> None :
void SetDOFVelocities(const std::vector< dReal > & dofvelocities, const Vector & linearvel, const Vector & angularvel, uint32_t checklimits = CLA_CheckLimits )
Sets the velocity of the base link and each of the joints.
- Parameters
- linearvel -
- linear velocity of base link
- angularvel -
- angular velocity rotation_axis*theta_dot
- dofvelocities -
- velocities of each of the degrees of freeom
- checklimits -
- one of CheckLimitsAction and will excplicitly check the joint velocity limits before setting the values and clamp them. Computes internally what the correponding velocities of each of the links should be in order to achieve consistent results with the joint velocities. Sends the velocities to the physics engine. Velocities correspond to the link’s coordinate system origin.
SetDOFVelocities( (KinBody)arg1, (object)dofvelocities, (int)checklimits, (object)indices) -> None
SetDOFVelocities( (KinBody)arg1, (object)dofvelocities, (object)linear, (object)angular, (int)checklimits) -> None :
void SetDOFVelocities(const std::vector< dReal > & dofvelocities, const Vector & linearvel, const Vector & angularvel, uint32_t checklimits = CLA_CheckLimits )
Sets the velocity of the base link and each of the joints.
- Parameters
- linearvel -
- linear velocity of base link
- angularvel -
- angular velocity rotation_axis*theta_dot
- dofvelocities -
- velocities of each of the degrees of freeom
- checklimits -
- one of CheckLimitsAction and will excplicitly check the joint velocity limits before setting the values and clamp them. Computes internally what the correponding velocities of each of the links should be in order to achieve consistent results with the joint velocities. Sends the velocities to the physics engine. Velocities correspond to the link’s coordinate system origin.
- KinBody.SetDOFVelocityLimits((KinBody)arg1, (object)limits) → None :¶
void SetDOFVelocityLimits(const std::vector< dReal > & maxlimits)
- See
- GetDOFVelocityLimits
- KinBody.SetDOFWeights((KinBody)arg1, (object)weights) → None :¶
void SetDOFWeights(const std::vector< dReal > & weights, const std::vector< int > & dofindices = std::vector< int >() )
sets dof weights
- Parameters
- dofindices -
- the dof indices to set the values for. If empty, will use all the dofs
- KinBody.SetJointTorques((KinBody)arg1, (object)torques, (bool)add) → None :¶
void SetDOFTorques(const std::vector< dReal > & torques, bool add)
Adds a torque to every joint.
- Parameters
- bAdd -
- if true, adds to previous torques, otherwise resets the torques on all bodies and starts from 0
- KinBody.SetJointValues((KinBody)arg1, (object)values) → None :¶
void SetDOFValues(const std::vector< dReal > & values, uint32_t checklimits = CLA_CheckLimits , const std::vector< int > & dofindices = std::vector< int >() )
Sets the joint values of the robot.
- Parameters
- values -
- the values to set the joint angles (ordered by the dof indices)
- checklimits -
- one of CheckLimitsAction and will excplicitly check the joint limits before setting the values and clamp them.
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
SetJointValues( (KinBody)arg1, (object)values, (object)dofindices) -> None :
void SetDOFValues(const std::vector< dReal > & values, uint32_t checklimits = CLA_CheckLimits , const std::vector< int > & dofindices = std::vector< int >() )
Sets the joint values of the robot.
- Parameters
- values -
- the values to set the joint angles (ordered by the dof indices)
- checklimits -
- one of CheckLimitsAction and will excplicitly check the joint limits before setting the values and clamp them.
- dofindices -
- the dof indices to return the values for. If empty, will compute for all the dofs
- KinBody.SetLinkTransformations((KinBody)arg1, (object)transforms[, (object)dofbranches]) → None :¶
void SetLinkTransformations(const std::vector< Transform > & transforms)
sets the transformations of all the links at once
- KinBody.SetLinkVelocities((KinBody)arg1, (object)velocities) → None :¶
void SetLinkVelocities(const std::vector< std::pair< Vector , Vector > > & velocities)
sets the link velocities
- KinBody.SetName((KinBody)arg1, (str)name) → None :¶
void SetName(const std::string & name)
Set the name of the robot, notifies the environment and checks for uniqueness.
- KinBody.SetNonCollidingConfiguration((KinBody)arg1) → None :¶
void SetNonCollidingConfiguration()
Treats the current pose as a pose not in collision, which sets the adjacent pairs of links.
- KinBody.SetTransform((KinBody)arg1, (object)transform) → None :¶
void SetTransform(const Transform & transform)
胴体の絶対姿勢を設定、残りのリンクは運動学の構造に従って変換される.
- Parameters
- transform -
- 変換行列
- KinBody.SetTransformWithDOFValues((KinBody)arg1, (object)transform, (object)values) → None :¶
void SetDOFValues(const std::vector< dReal > & values, const Transform & transform, uint32_t checklimits = CLA_CheckLimits )
Sets the joint values and transformation of the body.
- Parameters
- values -
- the values to set the joint angles (ordered by the dof indices)
- transform -
- represents the transformation of the first body.
- checklimits -
- one of CheckLimitsAction and will excplicitly check the joint limits before setting the values and clamp them.
- KinBody.SetTransformWithJointValues((KinBody)arg1, (object)transform, (object)values) → None :¶
void SetDOFValues(const std::vector< dReal > & values, const Transform & transform, uint32_t checklimits = CLA_CheckLimits )
Sets the joint values and transformation of the body.
- Parameters
- values -
- the values to set the joint angles (ordered by the dof indices)
- transform -
- represents the transformation of the first body.
- checklimits -
- one of CheckLimitsAction and will excplicitly check the joint limits before setting the values and clamp them.
- KinBody.SetVelocity((KinBody)arg1, (object)linear, (object)angular) → bool :¶
bool SetVelocity(const Vector & linearvel, const Vector & angularvel)
Set the velocity of the base link, rest of links are set to a consistent velocity so entire robot moves correctly.
- Parameters
- linearvel -
- linear velocity
- angularvel -
- is the rotation axis * angular speed
- KinBody.SetVisible((KinBody)arg1, (bool)visible) → bool :¶
bool SetVisible(bool visible)
Sets all the links as visible or not visible.
- Return
- true if changed
- KinBody.SetZeroConfiguration((KinBody)arg1) → None :¶
void SetZeroConfiguration()
Sets the joint offsets so that the current configuration becomes the new zero state of the robot.
When this function returns, the returned DOF values should be all zero for controllable joints. Mimic equations will use the new offsetted values when computing their joints. This is primarily used for calibrating a robot’s zero position
- KinBody.SubtractDOFValues((KinBody)arg1, (object)values0, (object)values1) → object :¶
void SubtractDOFValues(std::vector< dReal > & values1, const std::vector< dReal > & values2, const std::vector< int > & dofindices = std::vector< int >() )
Computes the configuration difference values1-values2 and stores it in values1.
- Parameters
- inout] -
- values1 the result is stored back in this
values2 -
- dofindices -
- the dof indices to compute the subtraction for. If empty, will compute for all the dofs Takes into account joint limits and wrapping of circular joints.
- KinBody.serialize((KinBody)arg1, (int)options) → str :¶
void serialize(std::ostream & o, int options)
only used for hashes...
- class openravepy.openravepy_int.Module¶
Bases: openravepy.openravepy_int.Interface
Raises an exception This class cannot be instantiated from Python
- Destroy((Module)arg1) → None¶
- SimulationStep((Module)arg1, (float)arg2) → bool¶
- class openravepy.openravepy_int.PhysicsEngine¶
Bases: openravepy.openravepy_int.Interface
Raises an exception This class cannot be instantiated from Python
- AddJointTorque((PhysicsEngine)arg1, (object)arg2, (object)arg3) → bool :¶
bool AddJointTorque(KinBody::JointPtr pjoint, const std::vector< dReal > & pTorques)
- Parameters
- pjoint -
- the joint the torque is added to
- pTorques -
- the torques added to the joint. Pointer because the joint dof can be greater than 1. adds torque to a joint
- DestroyEnvironment((PhysicsEngine)arg1) → None :¶
void DestroyEnvironment()
called when environment switches to a different physics engine has to clear/deallocate any memory associated with KinBody::_pPhysicsData
- GetGravity((PhysicsEngine)arg1) → object :¶
Vector GetGravity()
- GetLinkForceTorque((PhysicsEngine)arg1, (object)arg2) → object :¶
bool GetLinkForceTorque(KinBody::LinkConstPtr link, Vector & force, Vector & torque)
- Parameters
- link -
- a constant pointer to a link
- force -
- current force on the COM of the link
- torque -
- current torque on the COM of the link
- GetLinkVelocities((PhysicsEngine)arg1, (object)arg2) → object :¶
bool GetLinkVelocities(KinBodyConstPtr body, std::vector< std::pair< Vector , Vector > > & velocities)
Sets the velocities for each link, velocities correspond to the link’s coordinate system origin.
- Parameters
- velocities -
- the linear and angular (axis * angular_speed) velocities for each link.
- GetLinkVelocity((PhysicsEngine)arg1, (object)arg2) → object :¶
bool GetLinkVelocity(KinBody::LinkConstPtr link, Vector & linearvel, Vector & angularvel)
Gets the velocity of a link, velocities correspond to the link’s coordinate system origin.
- Parameters
- linearvel -
- linear velocity of base link
- angularvel -
- angular velocity rotation_axis*theta_dot
- GetPhysicsOptions((PhysicsEngine)arg1) → int :¶
int GetPhysicsOptions()
- InitEnvironment((PhysicsEngine)arg1) → bool :¶
bool InitEnvironment()
called when environment sets this physics engine, engine assumes responsibility for KinBody::_pPhysicsData
- InitKinBody((PhysicsEngine)arg1, (KinBody)arg2) → bool :¶
bool InitKinBody(KinBodyPtr body)
notified when a new body has been initialized in the environment
- SetBodyForce((PhysicsEngine)arg1, (object)arg2, (object)arg3, (object)arg4, (bool)arg5) → bool :¶
bool SetBodyForce(KinBody::LinkPtr link, const Vector & force, const Vector & position, bool bAdd)
- Parameters
- force -
- the direction and magnitude of the force
- position -
- in the world where the force is getting applied
- bAdd -
- if true, force is added to previous forces, otherwise it is set add a force at a particular position in a link
- SetBodyTorque((PhysicsEngine)arg1, (object)arg2, (object)arg3, (bool)arg4) → bool :¶
bool SetBodyTorque(KinBody::LinkPtr link, const Vector & torque, bool bAdd)
- Parameters
- link -
- the link to add a torque to
- torque -
- torque vector
- bAdd -
- if true, torque is added to previous torques, otherwise it is set adds torque to a body (absolute coords)
- SetGravity((PhysicsEngine)arg1, (object)arg2) → None :¶
void SetGravity(const Vector & gravity)
set the gravity direction
- Parameters
joint -
- force -
- current accumulated force on the COM of the link
- torque -
- current accumulated torque on the COM of the link
- SetLinkVelocities((PhysicsEngine)arg1, (object)arg2, (object)body, (object)velocities) → bool :¶
bool SetLinkVelocities(KinBodyPtr body, const std::vector< std::pair< Vector , Vector > > & velocities)
Sets the velocities for each link, velocities correspond to the link’s coordinate system origin.
- Parameters
- body -
- the body to query velocities from.
- velocities -
- sets the linear and angular (axis * angular_speed) velocities for each link
- SetLinkVelocity((PhysicsEngine)arg1, (object)arg2, (object)link, (object)velocity) → bool :¶
bool SetLinkVelocity(KinBody::LinkPtr link, const Vector & linearvel, const Vector & angularvel)
Force the body velocity of a link, velocities correspond to the link’s coordinate system origin.
- Parameters
- link -
- link to set velocities.
- linearvel -
- linear velocity of base link
- angularvel -
- angular velocity rotation_axis*theta_dot
- SetPhysicsOptions((PhysicsEngine)arg1, (int)arg2) → bool :¶
bool SetPhysicsOptions(int physicsoptions)
Set basic physics engine using the PhysicsEngineOptions enum.
- SimulateStep((PhysicsEngine)arg1, (float)arg2) → None :¶
void SimulateStep(dReal fTimeElapsed)
dynamically simulate system for fTimeElapsed seconds add torques to the joints of the body. Torques disappear after one timestep of simulation
- class openravepy.openravepy_int.PhysicsEngineOptions¶
Bases: Boost.Python.enum
PhysicsEngineOptions
basic options for physics engine- SelfCollisions = openravepy.openravepy_int.PhysicsEngineOptions.SelfCollisions¶
- names = {'SelfCollisions': openravepy.openravepy_int.PhysicsEngineOptions.SelfCollisions}¶
- values = {1: openravepy.openravepy_int.PhysicsEngineOptions.SelfCollisions}¶
- class openravepy.openravepy_int.Planner¶
Bases: openravepy.openravepy_int.Interface
Raises an exception This class cannot be instantiated from Python
- GetParameters((Planner)arg1) → PlannerParameters :¶
PlannerParametersConstPtr GetParameters()
return the internal parameters of the planner
- InitPlan((Planner)arg1, (Robot)robot, (PlannerParameters)params[, (bool)releasegil]) → bool :¶
bool InitPlan(RobotBasePtr robot, PlannerParametersConstPtr params)
Setup scene, robot, and properties of the plan, and reset all internal structures.
- Parameters
- robot -
- main robot to be used for planning
- params -
- The parameters of the planner, any class derived from PlannerParameters can be passed. The planner should copy these parameters for future instead of storing the pointer.
InitPlan( (Planner)arg1, (Robot)robot, (str)xmlparams) -> bool :
bool InitPlan(RobotBasePtr robot, std::istream & isParameters)
Setup scene, robot, and properties of the plan, and reset all structures with pparams.
- Parameters
- robot -
- main robot to be used for planning
- isParameters -
- The serialized form of the parameters. By default, this exists to allow third parties to pass information to planners without excplicitly knowning the format/internal structures used
- Return
- true if plan is initialized successfully and initial conditions are satisfied.
- PlanPath((Planner)arg1, (Trajectory)traj[, (bool)releasegil]) → PlannerStatus :¶
PlannerStatus PlanPath(TrajectoryBasePtr ptraj)
Executes the main planner trying to solve for the goal condition.
- Parameters
- ptraj -
- The output trajectory the robot has to follow in order to successfully complete the plan. If this planner is a path optimizer, the trajectory can be used as an input for generating a smoother path. The trajectory is for the configuration degrees of freedom defined by the planner parameters. Fill ptraj with the trajectory of the planned path that the robot needs to execute
- Return
- the status that the planner returned in.
- class PlannerParameters¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
__init__( (object)arg1) -> None
__init__( (object)arg1, (PlannerParameters)parameters) -> None
- SetConfigurationSpecification((PlannerParameters)arg1, (Environment)env, (ConfigurationSpecification)spec) → None¶
- SetExtraParameters((PlannerParameters)arg1, (str)extra) → None¶
- SetGoalConfig((PlannerParameters)arg1, (object)values) → None :¶
sets PlannerParameters::vgoalconfig
- SetInitialConfig((PlannerParameters)arg1, (object)values) → None :¶
sets PlannerParameters::vinitialconfig
- SetRobotActiveJoints((PlannerParameters)arg1, (Robot)robot) → None¶
- class openravepy.openravepy_int.PlannerAction¶
Bases: Boost.Python.enum
PlannerAction
action to send to the planner while it is planning. This is usually done by the user-specified planner callback function- Interrupt = openravepy.openravepy_int.PlannerAction.Interrupt¶
- None = openravepy.openravepy_int.PlannerAction.None¶
- ReturnWithAnySolution = openravepy.openravepy_int.PlannerAction.ReturnWithAnySolution¶
- names = {'Interrupt': openravepy.openravepy_int.PlannerAction.Interrupt, 'None': openravepy.openravepy_int.PlannerAction.None, 'ReturnWithAnySolution': openravepy.openravepy_int.PlannerAction.ReturnWithAnySolution}¶
- values = {0: openravepy.openravepy_int.PlannerAction.None, 1: openravepy.openravepy_int.PlannerAction.Interrupt, 2: openravepy.openravepy_int.PlannerAction.ReturnWithAnySolution}¶
- class openravepy.openravepy_int.PlannerProgress¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
- class openravepy.openravepy_int.PlannerStatus¶
Bases: Boost.Python.enum
PlannerStatus
the status of the PlanPath method. Used when PlanPath can be called multiple times to resume planning.- Failed = openravepy.openravepy_int.PlannerStatus.Failed¶
- HasSolution = openravepy.openravepy_int.PlannerStatus.HasSolution¶
- Interrupted = openravepy.openravepy_int.PlannerStatus.Interrupted¶
- InterruptedWithSolution = openravepy.openravepy_int.PlannerStatus.InterruptedWithSolution¶
- names = {'InterruptedWithSolution': openravepy.openravepy_int.PlannerStatus.InterruptedWithSolution, 'Failed': openravepy.openravepy_int.PlannerStatus.Failed, 'Interrupted': openravepy.openravepy_int.PlannerStatus.Interrupted, 'HasSolution': openravepy.openravepy_int.PlannerStatus.HasSolution}¶
- values = {0: openravepy.openravepy_int.PlannerStatus.Failed, 1: openravepy.openravepy_int.PlannerStatus.HasSolution, 2: openravepy.openravepy_int.PlannerStatus.Interrupted, 3: openravepy.openravepy_int.PlannerStatus.InterruptedWithSolution}¶
- class openravepy.openravepy_int.PluginInfo¶
Bases: Boost.Python.instance
Raises an exception This class cannot be instantiated from Python
- interfacenames¶
- version¶
- openravepy.openravepy_int.RaveClone((Interface)ref, (int)cloningoptions) → Interface :¶
boost::shared_ptr< T > RaveClone(boost::shared_ptr< T const > preference, int cloningoptions)
returned a fully cloned interface
- openravepy.openravepy_int.RaveCreateCollisionChecker((Environment)env, (str)name) → CollisionChecker :¶
OPENRAVE_API CollisionCheckerBasePtr RaveCreateCollisionChecker(EnvironmentBasePtr penv, const std::string & name)
- openravepy.openravepy_int.RaveCreateController((Environment)env, (str)name) → Controller :¶
OPENRAVE_API ControllerBasePtr RaveCreateController(EnvironmentBasePtr penv, const std::string & name)
- openravepy.openravepy_int.RaveCreateIkSolver((Environment)env, (str)name) → IkSolver :¶
OPENRAVE_API IkSolverBasePtr RaveCreateIkSolver(EnvironmentBasePtr penv, const std::string & name)
- openravepy.openravepy_int.RaveCreateInterface((Environment)env, (InterfaceType)type, (str)name) → Interface :¶
OPENRAVE_API InterfaceBasePtr RaveCreateInterface(EnvironmentBasePtr penv, InterfaceType type, const std::string & interfacename)
- openravepy.openravepy_int.RaveCreateKinBody((Environment)env, (str)name) → KinBody :¶
OPENRAVE_API KinBodyPtr RaveCreateKinBody(EnvironmentBasePtr penv, const std::string & name = “” )
- openravepy.openravepy_int.RaveCreateModule((Environment)env, (str)name) → Module :¶
OPENRAVE_API ModuleBasePtr RaveCreateModule(EnvironmentBasePtr penv, const std::string & name)
- openravepy.openravepy_int.RaveCreatePhysicsEngine((Environment)env, (str)name) → PhysicsEngine :¶
OPENRAVE_API PhysicsEngineBasePtr RaveCreatePhysicsEngine(EnvironmentBasePtr penv, const std::string & name)
- openravepy.openravepy_int.RaveCreatePlanner((Environment)env, (str)name) → Planner :¶
OPENRAVE_API PlannerBasePtr RaveCreatePlanner(EnvironmentBasePtr penv, const std::string & name)
- openravepy.openravepy_int.RaveCreateProblem((Environment)env, (str)name) → Module :¶
OPENRAVE_API ModuleBasePtr RaveCreateModule(EnvironmentBasePtr penv, const std::string & name)
- openravepy.openravepy_int.RaveCreateProblemInstance((Environment)env, (str)name) → Module :¶
OPENRAVE_API ModuleBasePtr RaveCreateModule(EnvironmentBasePtr penv, const std::string & name)
- openravepy.openravepy_int.RaveCreateRobot((Environment)env, (str)name) → Robot :¶
OPENRAVE_API RobotBasePtr RaveCreateRobot(EnvironmentBasePtr penv, const std::string & name = “” )
- openravepy.openravepy_int.RaveCreateSensor((Environment)env, (str)name) → Sensor :¶
OPENRAVE_API SensorBasePtr RaveCreateSensor(EnvironmentBasePtr penv, const std::string & name)
- openravepy.openravepy_int.RaveCreateSensorSystem((Environment)env, (str)name) → SensorSystem :¶
OPENRAVE_API SensorSystemBasePtr RaveCreateSensorSystem(EnvironmentBasePtr penv, const std::string & name)
- openravepy.openravepy_int.RaveCreateSpaceSampler((Environment)env, (str)name) → SpaceSampler :¶
OPENRAVE_API SpaceSamplerBasePtr RaveCreateSpaceSampler(EnvironmentBasePtr penv, const std::string & name)
- openravepy.openravepy_int.RaveCreateTrajectory((Environment)env, (str)name) → Trajectory :¶
OPENRAVE_API TrajectoryBasePtr RaveCreateTrajectory(EnvironmentBasePtr penv, const std::string & name = “” )
Return an empty trajectory instance.
- openravepy.openravepy_int.RaveCreateViewer((Environment)env, (str)name) → Viewer :¶
OPENRAVE_API ViewerBasePtr RaveCreateViewer(EnvironmentBasePtr penv, const std::string & name)
- openravepy.openravepy_int.RaveDestroy() → None :¶
OPENRAVE_API void RaveDestroy()
Destroys the entire OpenRAVE state and all loaded environments.
This functions should be always called before program shutdown in order to assure all resources are relased appropriately.
- openravepy.openravepy_int.RaveFindDatabaseFile((str)arg1, (bool)arg2) → str :¶
OPENRAVE_API std::string RaveFindDatabaseFile(const std::string & filename, bool bRead = true )
Searches for a filename in the database and returns a full path/URL to it.
- Parameters
- filename -
- the relative filename in the database
- bRead -
- if true will only return a file if it exists. If false, will return the filename of the first valid database directory.
- Return
- a non-empty string if a file could be found.
- openravepy.openravepy_int.RaveFindLocalFile((str)filename[, (str)curdir]) → str¶
- openravepy.openravepy_int.RaveGetAffineConfigurationSpecification((int)affinedofs[, (KinBody)body[, (str)interpolation]]) → ConfigurationSpecification :¶
OPENRAVE_API ConfigurationSpecification RaveGetAffineConfigurationSpecification(int affinedofs, KinBodyConstPtr pbody = KinBodyConstPtr () , const std::string & interpolation = “” )
- openravepy.openravepy_int.RaveGetAffineDOF((int)affinedofs) → int :¶
OPENRAVE_API int RaveGetAffineDOF(int affinedofs)
Returns the degrees of freedom needed to represent all the values in the affine dof mask.
- Exceptions
- openrave_exception -
- throws if
- openravepy.openravepy_int.RaveGetAffineDOFFromIndex((int)affinedofs, (int)index) → DOFAffine :¶
OPENRAVE_API DOFAffine RaveGetAffineDOFFromIndex(int affinedofs, int index)
Given a mask of affine dofs and an index into the array, returns the affine dof that is being referenced.
- Parameters
- affinedofs -
- a mask of DOFAffine values
- index -
- an index into the affine dof array Exceptions
- openrave_exception -
- throws if dof if index is out of bounds
- openravepy.openravepy_int.RaveGetAffineDOFValuesFromTransform((object)transform, (int)affinedofs[, (object)rotationaxis]) → object :¶
OPENRAVE_API void RaveGetAffineDOFValuesFromTransform(std::vector< dReal >::iterator itvalues, const Transform & t, int affinedofs, const Vector & vActvAffineRotationAxis = Vector (0, 0, 1) )
Converts the transformation matrix into the specified affine values format.
- Parameters
- itvalues -
- an iterator to the vector to write the values to. Will write exactly RaveGetAffineDOF(affinedofs) values.
- the -
- affine transformation to convert
- affinedofs -
- the affine format to output values in
- vActvAffineRotationAxis -
- optional rotation axis if affinedofs specified DOF_RotationAxis
- openravepy.openravepy_int.RaveGetDataAccess() → int :¶
OPENRAVE_API int RaveGetDataAccess()
Returns the acess options set.
- See
- RaveSetDataAccess
- openravepy.openravepy_int.RaveGetDebugLevel() → int :¶
OPENRAVE_API int RaveGetDebugLevel()
Returns the openrave debug level.
- openravepy.openravepy_int.RaveGetEnvironment((int)arg1) → Environment :¶
OPENRAVE_API EnvironmentBasePtr RaveGetEnvironment(int id)
get the environment from its unique id
- Parameters
- id -
- the unique environment id returned by RaveGetEnvironmentId
- openravepy.openravepy_int.RaveGetEnvironmentId((Environment)arg1) → int :¶
OPENRAVE_API int RaveGetEnvironmentId(EnvironmentBasePtr penv)
return the environment’s unique id, returns 0 if environment could not be found or not registered
- openravepy.openravepy_int.RaveGetEnvironments() → object :¶
OPENRAVE_API void RaveGetEnvironments(std::list< EnvironmentBasePtr > & listenvironments)
Return all the created OpenRAVE environments.
- openravepy.openravepy_int.RaveGetHomeDirectory() → str :¶
OPENRAVE_API std::string RaveGetHomeDirectory()
Returns the openrave home directory where settings, cache, and other files are stored.
On Linux/Unix systems, this is usually $HOME/.openrave, on Windows this is $HOMEPATH/.openrave
- openravepy.openravepy_int.RaveGetIkTypeFromUniqueId((int)uniqueid) → IkParameterizationType :¶
OPENRAVE_API IkParameterizationType RaveGetIkTypeFromUniqueId(int uniqueid)
returns the IkParameterizationType given the unique id detmerined b IKP_UniqueIdMask
- openravepy.openravepy_int.RaveGetIndexFromAffineDOF((int)affinedofs, (DOFAffine)dof) → int :¶
OPENRAVE_API int RaveGetIndexFromAffineDOF(int affinedofs, DOFAffine dof)
Given a mask of affine dofs and a dof inside that mask, returns the index where the value could be found.
- Parameters
- affinedofs -
- a mask of DOFAffine values
- dof -
- a set of values inside affinedofs, the index of the first value is returned Exceptions
- openrave_exception -
- throws if dof is not present in affinedofs
- openravepy.openravepy_int.RaveGetLoadedInterfaces() → object :¶
OPENRAVE_API void RaveGetLoadedInterfaces(std::map< InterfaceType, std::vector< std::string > > & interfacenames)
Get a list of all the loaded interfaces.
- openravepy.openravepy_int.RaveGetPluginInfo() → object :¶
OPENRAVE_API void RaveGetPluginInfo(std::list< std::pair< std::string, PLUGININFO > > & plugins)
Get all the loaded plugins and the interfaces they support.
- Parameters
- plugins -
- A list of plugins. Each entry has the plugin name and the interfaces it supports
- openravepy.openravepy_int.RaveGlobalState() → UserData :¶
OPENRAVE_API UserDataPtr RaveGlobalState()
A pointer to the global openrave state.
- Return
- a managed pointer to the state.
- openravepy.openravepy_int.RaveHasInterface((InterfaceType)type, (str)name) → bool :¶
OPENRAVE_API bool RaveHasInterface(InterfaceType type, const std::string & interfacename)
Returns true if interface can be created, otherwise false.
- openravepy.openravepy_int.RaveInitialize([(bool)load_all_plugins[, (object)level]]) → int :¶
OPENRAVE_API int RaveInitialize(bool bLoadAllPlugins = true , int level = Level_Info )
Explicitly initializes the global OpenRAVE state (optional).
- Parameters
- bLoadAllPlugins -
- If true will load all the openrave plugins automatically that can be found in the OPENRAVE_PLUGINS environment path Optional function to initialize openrave plugins, logging, and read OPENRAVE_* environment variables. Although environment creation will automatically make sure this function is called, users might want explicit control of when this happens. Will not do anything if OpenRAVE runtime is already initialized. If OPENRAVE_* environment variables must be re-read, first call RaveDestroy.
- Return
- 0 if successful, otherwise an error code
- openravepy.openravepy_int.RaveLoadPlugin((str)filename) → bool¶
- openravepy.openravepy_int.RaveLog((str)log, (int)level) → None :¶
Send a log to the openrave system with excplicit level
- openravepy.openravepy_int.RaveLogDebug((str)log) → None :¶
Send a debug log to the openrave system
- openravepy.openravepy_int.RaveLogError((str)log) → None :¶
Send an error log to the openrave system
- openravepy.openravepy_int.RaveLogFatal((str)log) → None :¶
Send a fatal log to the openrave system
- openravepy.openravepy_int.RaveLogInfo((str)log) → None :¶
Send an info log to the openrave system
- openravepy.openravepy_int.RaveLogVerbose((str)log) → None :¶
Send a verbose log to the openrave system
- openravepy.openravepy_int.RaveLogWarn((str)log) → None :¶
Send a warn log to the openrave system
- openravepy.openravepy_int.RaveReloadPlugins() → None :¶
OPENRAVE_API void RaveReloadPlugins()
Reloads all the plugins.
The interfaces currently created remain will continue using the old plugins, so this function is safe in that plugins currently loaded remain loaded until the last interface that uses them is released.
- openravepy.openravepy_int.RaveSetDataAccess((object)accessoptions) → None :¶
OPENRAVE_API void RaveSetDataAccess(int accessoptions)
Sets the default data access options for cad resources/robot files.
- Parameters
- accessoptions -
- if 1 will only allow resources inside directories specified from OPERNAVE_DATA environment variable. This allows reject of full paths from unsecure/unauthenticated resources. Controls how files are processed in functions like RaveFindLocalFile
- openravepy.openravepy_int.RaveSetDebugLevel((object)level) → None :¶
OPENRAVE_API void RaveSetDebugLevel(int level)
Sets the global openrave debug level. A combination of DebugLevel.
- class openravepy.openravepy_int.Ray¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
__init__( (object)arg1, (object)pos, (object)dir) -> None
- dir((Ray)arg1) → object¶
- pos((Ray)arg1) → object¶
- class openravepy.openravepy_int.Robot¶
Bases: openravepy.openravepy_int.KinBody, openravepy.openravepy_int.Interface
Raises an exception This class cannot be instantiated from Python
- AddManipulator((Robot)arg1, (ManipulatorInfo)manip) → Manipulator :¶
ManipulatorPtr AddManipulator(const ManipulatorInfo & manipinfo)
adds a manipulator the list
- Exceptions
- openrave_exception -
- If there exists a manipulator with the same name, will throw an exception Will copy the information of this manipulator object into a new manipulator and initialize it with the robot. Will change the robot structure hash..
- Return
- the new manipulator attached to the robot
- class AttachedSensor¶
Bases: Boost.Python.instance
Raises an exception This class cannot be instantiated from Python
- GetAttachingLink((AttachedSensor)arg1) → object :¶
LinkPtr GetAttachingLink()
- GetData((AttachedSensor)arg1) → object :¶
SensorBase::SensorDataPtr GetData()
retrieves the current data from the sensor
- GetName((AttachedSensor)arg1) → object :¶
const std::string & GetName()
- GetRelativeTransform((AttachedSensor)arg1) → object :¶
Transform GetRelativeTransform()
- GetRobot((AttachedSensor)arg1) → Robot :¶
RobotBasePtr GetRobot()
- GetSensor((AttachedSensor)arg1) → object :¶
SensorBasePtr GetSensor()
- GetStructureHash((AttachedSensor)arg1) → str :¶
const std::string & GetStructureHash()
- Return
- hash of the sensor definition
- GetTransform((AttachedSensor)arg1) → object :¶
Transform GetTransform()
- SetRelativeTransform((AttachedSensor)arg1, (object)transform) → None :¶
void SetRelativeTransform(const Transform & t)
- Robot.CalculateActiveAngularVelocityJacobian((Robot)arg1, (int)linkindex) → object :¶
void CalculateActiveAngularVelocityJacobian(int index, std::vector< dReal > & jacobian)
- Calculates the angular velocity jacobian of a specified link about the axes of world coordinates.Parameters
- index -
- of the link that the rotation is attached to
- mjacobian -
- 3x(num ACTIVE DOF) matrix
- Robot.CalculateActiveJacobian((Robot)arg1, (int)linkindex, (object)offset) → object :¶
void CalculateActiveJacobian(int index, const Vector & offset, std::vector< dReal > & jacobian)
Calculates the translation jacobian with respect to a link.
- Parameters
- mjacobian -
- a 3 x ActiveDOF matrix Calculates the partial differentials for the active degrees of freedom that in the path from the root node to _veclinks[index] (doesn’t touch the rest of the values).
- Robot.CalculateActiveRotationJacobian((Robot)arg1, (int)linkindex, (object)quat) → object :¶
void CalculateActiveRotationJacobian(int index, const Vector & qInitialRot, std::vector< dReal > & jacobian)
- Robot.CreateRobotStateSaver((Robot)arg1[, (object)options]) → StateRestoreContext :¶
Creates an object that can be entered using ‘with’ and returns a RobotStateSaver
- class Robot.DOFAffine¶
Bases: Boost.Python.enum
DOFAffine
Selects which DOFs of the affine transformation to include in the active configuration.- NoTransform = openravepy.openravepy_int.DOFAffine.NoTransform¶
- Rotation3D = openravepy.openravepy_int.DOFAffine.Rotation3D¶
- RotationAxis = openravepy.openravepy_int.DOFAffine.RotationAxis¶
- RotationMask = openravepy.openravepy_int.DOFAffine.RotationMask¶
- RotationQuat = openravepy.openravepy_int.DOFAffine.RotationQuat¶
- Transform = openravepy.openravepy_int.DOFAffine.Transform¶
- X = openravepy.openravepy_int.DOFAffine.X¶
- Y = openravepy.openravepy_int.DOFAffine.Y¶
- Z = openravepy.openravepy_int.DOFAffine.Z¶
- names = {'NoTransform': openravepy.openravepy_int.DOFAffine.NoTransform, 'Rotation3D': openravepy.openravepy_int.DOFAffine.Rotation3D, 'RotationQuat': openravepy.openravepy_int.DOFAffine.RotationQuat, 'RotationAxis': openravepy.openravepy_int.DOFAffine.RotationAxis, 'Transform': openravepy.openravepy_int.DOFAffine.Transform, 'RotationMask': openravepy.openravepy_int.DOFAffine.RotationMask, 'Y': openravepy.openravepy_int.DOFAffine.Y, 'X': openravepy.openravepy_int.DOFAffine.X, 'Z': openravepy.openravepy_int.DOFAffine.Z}¶
- values = {0: openravepy.openravepy_int.DOFAffine.NoTransform, 1: openravepy.openravepy_int.DOFAffine.X, 2: openravepy.openravepy_int.DOFAffine.Y, 4: openravepy.openravepy_int.DOFAffine.Z, 32: openravepy.openravepy_int.DOFAffine.RotationQuat, 8: openravepy.openravepy_int.DOFAffine.RotationAxis, 39: openravepy.openravepy_int.DOFAffine.Transform, 16: openravepy.openravepy_int.DOFAffine.Rotation3D, 56: openravepy.openravepy_int.DOFAffine.RotationMask}¶
- Robot.GetActiveConfigurationSpecification((Robot)arg1[, (str)interpolation]) → object :¶
ConfigurationSpecification GetActiveConfigurationSpecification(const std::string & interpolation = “” )
return a copy of the configuration specification of the active dofs
Note that the return type is by-value, so should not be used in iteration
- Robot.GetActiveDOF((Robot)arg1) → int :¶
int GetActiveDOF()
- Robot.GetActiveDOFIndices((Robot)arg1) → object :¶
const std::vector< int > & GetActiveDOFIndices()
Return the set of active dof indices of the joints.
- Robot.GetActiveDOFLimits((Robot)arg1) → object :¶
void GetActiveDOFLimits(std::vector< dReal > & lower, std::vector< dReal > & upper)
- Robot.GetActiveDOFMaxAccel((Robot)arg1) → object :¶
void GetActiveDOFMaxAccel(std::vector< dReal > & v)
- Robot.GetActiveDOFMaxVel((Robot)arg1) → object :¶
void GetActiveDOFMaxVel(std::vector< dReal > & v)
- Robot.GetActiveDOFResolutions((Robot)arg1) → object :¶
void GetActiveDOFResolutions(std::vector< dReal > & v)
- Robot.GetActiveDOFValues((Robot)arg1) → object :¶
void GetActiveDOFValues(std::vector< dReal > & v)
- Robot.GetActiveDOFVelocities((Robot)arg1) → object :¶
void GetActiveDOFVelocities(std::vector< dReal > & velocities)
- Robot.GetActiveDOFWeights((Robot)arg1) → object :¶
void GetActiveDOFWeights(std::vector< dReal > & v)
- Robot.GetActiveJointIndices((Robot)arg1) → object¶
- Robot.GetActiveManipulator((Robot)arg1) → Manipulator :¶
ManipulatorPtr GetActiveManipulator()
- Robot.GetActiveManipulatorIndex((Robot)arg1) → int :¶
int GetActiveManipulatorIndex()
- Robot.GetAffineDOF((Robot)arg1) → int :¶
int GetAffineDOF()
- Robot.GetAffineDOFIndex((Robot)arg1, (DOFAffine)index) → int :¶
int GetAffineDOFIndex(DOFAffine dof)
- Robot.GetAffineRotation3DLimits((Robot)arg1) → object :¶
void GetAffineRotation3DLimits(Vector & lower, Vector & upper)
- Robot.GetAffineRotation3DMaxVels((Robot)arg1) → object :¶
Vector GetAffineRotation3DMaxVels()
- Robot.GetAffineRotation3DResolution((Robot)arg1) → object :¶
Vector GetAffineRotation3DResolution()
- Robot.GetAffineRotation3DWeights((Robot)arg1) → object :¶
Vector GetAffineRotation3DWeights()
- Robot.GetAffineRotationAxis((Robot)arg1) → object :¶
Vector GetAffineRotationAxis()
- Robot.GetAffineRotationAxisLimits((Robot)arg1) → object :¶
void GetAffineRotationAxisLimits(Vector & lower, Vector & upper)
- Robot.GetAffineRotationAxisMaxVels((Robot)arg1) → object :¶
Vector GetAffineRotationAxisMaxVels()
- Robot.GetAffineRotationAxisResolution((Robot)arg1) → object :¶
Vector GetAffineRotationAxisResolution()
- Robot.GetAffineRotationAxisWeights((Robot)arg1) → object :¶
Vector GetAffineRotationAxisWeights()
- Robot.GetAffineRotationQuatLimits((Robot)arg1) → object :¶
Vector GetAffineRotationQuatLimits()
gets the quaternion limits
- Parameters
- quatangle -
- quaternion_start * max_angle. acos(q dot quaternion_start) <= max_angle
- Robot.GetAffineRotationQuatMaxVels((Robot)arg1) → float :¶
dReal GetAffineRotationQuatMaxVels()
- Robot.GetAffineRotationQuatResolution((Robot)arg1) → float :¶
dReal GetAffineRotationQuatResolution()
- Robot.GetAffineRotationQuatWeights((Robot)arg1) → float :¶
dReal GetAffineRotationQuatWeights()
- Robot.GetAffineTranslationLimits((Robot)arg1) → object :¶
void GetAffineTranslationLimits(Vector & lower, Vector & upper)
- Robot.GetAffineTranslationMaxVels((Robot)arg1) → object :¶
Vector GetAffineTranslationMaxVels()
- Robot.GetAffineTranslationResolution((Robot)arg1) → object :¶
Vector GetAffineTranslationResolution()
- Robot.GetAffineTranslationWeights((Robot)arg1) → object :¶
Vector GetAffineTranslationWeights()
- Robot.GetAttachedSensor((Robot)arg1, (str)sensorname) → AttachedSensor :¶
Return the attached sensor whose name matches
- Robot.GetAttachedSensors((Robot)arg1) → object :¶
std::vector< AttachedSensorPtr > & GetAttachedSensors()
- Robot.GetController((Robot)arg1) → object :¶
ControllerBasePtr GetController()
gets the robot controller
- Robot.GetGrabbed((Robot)arg1) → object :¶
void GetGrabbed(std::vector< KinBodyPtr > & vbodies)
gets all grabbed bodies of the robot
- Parameters
- vbodies -
- filled with the grabbed bodies
- Robot.GetGrabbedInfo((Robot)arg1) → object¶
- Robot.GetManipulator((Robot)arg1, (str)manipname) → Manipulator :¶
Return the manipulator whose name matches
- Robot.GetManipulators((Robot)arg1) → object :¶
std::vector< ManipulatorPtr > & GetManipulators()
Returns the manipulators of the robot.GetManipulators( (Robot)arg1, (str)manipname) -> object :
std::vector< ManipulatorPtr > & GetManipulators()
Returns the manipulators of the robot.
- Robot.GetRobotStructureHash((Robot)arg1) → str :¶
const std::string & GetRobotStructureHash()
A md5 hash unique to the particular robot structure that involves manipulation and sensing components The serialization for the attached sensors will not involve any sensor specific properties (since they can change through calibration)
- Robot.GetSensor((Robot)arg1, (str)sensorname) → AttachedSensor¶
- Robot.GetSensors((Robot)arg1) → object¶
- Robot.Grab((Robot)arg1, (KinBody)body) → bool :¶
bool Grab(KinBodyPtr body)
Grabs the body with the active manipulator’s end effector.
- Parameters
- body -
- the body to be grabbed
- Return
- true if successful and body is grabbed
Grab( (Robot)arg1, (KinBody)body, (object)grablink) -> bool :
bool Grab(KinBodyPtr body, LinkPtr pRobotLinkToGrabWith)
Grab a body with the specified link.
- Parameters
- body -
- the body to be grabbed
- pRobotLinkToGrabWith -
- the link of this robot that will perform the grab
- Return
- true if successful and body is grabbed/
Grab( (Robot)arg1, (KinBody)body, (object)grablink, (object)linkstoignore) -> bool :
bool Grab(KinBodyPtr body, LinkPtr pRobotLinkToGrabWith, const std::set< int > & setRobotLinksToIgnore)
Grab the body with the specified link.
- Parameters
- body -
- the body to be grabbed
- pRobotLinkToGrabWith -
- the link of this robot that will perform the grab
- setRobotLinksToIgnore -
- Additional robot link indices that collision checker ignore when checking collisions between the grabbed body and the robot.
- Return
- true if successful and body is grabbed.
- class Robot.GrabbedInfo¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
- Robot.Init((Robot)arg1, (object)linkinfos, (object)jointinfos, (object)manipinfos, (object)attachedsensorinfos) → bool¶
- Robot.IsGrabbing((Robot)arg1, (KinBody)body) → object :¶
LinkPtr IsGrabbing(KinBodyConstPtr body)
return the robot link that is currently grabbing the body. If the body is not grabbed, will return an empty pointer.
- Parameters
- body -
- the body to check
- class Robot.Manipulator¶
Bases: Boost.Python.instance
Raises an exception This class cannot be instantiated from Python
- CalculateAngularVelocityJacobian((Manipulator)arg1) → object :¶
void CalculateAngularVelocityJacobian(std::vector< dReal > & jacobian)
computes the angule axis jacobian of the manipulator arm indices.
- CalculateJacobian((Manipulator)arg1) → object :¶
void CalculateJacobian(std::vector< dReal > & jacobian)
computes the jacobian of the manipulator arm indices of the current manipulator frame world position.
The manipulator frame is computed from Manipulator::GetTransform()
- CalculateRotationJacobian((Manipulator)arg1) → object :¶
void CalculateRotationJacobian(std::vector< dReal > & jacobian)
computes the quaternion jacobian of the manipulator arm indices from the current manipulator frame rotation.
- CheckEndEffectorCollision((Manipulator)arg1, (object)transform) → bool :¶
bool CheckEndEffectorCollision(const Transform & tEE, CollisionReportPtr report = CollisionReportPtr () )
Checks collision with only the gripper given its end-effector transform. Ignores disabled links.
- Parameters
- tEE -
- the end effector transform
- report -
- [optional] collision report
- Return
- true if a collision occurred
CheckEndEffectorCollision( (Manipulator)arg1, (object)transform, (CollisionReport)report) -> bool :
bool CheckEndEffectorCollision(const Transform & tEE, CollisionReportPtr report = CollisionReportPtr () )
Checks collision with only the gripper given its end-effector transform. Ignores disabled links.
- Parameters
- tEE -
- the end effector transform
- report -
- [optional] collision report
- Return
- true if a collision occurred
- CheckIndependentCollision((Manipulator)arg1) → bool :¶
bool CheckIndependentCollision(CollisionReportPtr report = CollisionReportPtr () )
Checks collision with the environment with all the independent links of the robot. Ignores disabled links.
- Parameters
- report -
- [optional] collision report
- Return
- true if a collision occurred
CheckIndependentCollision( (Manipulator)arg1, (CollisionReport)report) -> bool :
bool CheckIndependentCollision(CollisionReportPtr report = CollisionReportPtr () )
Checks collision with the environment with all the independent links of the robot. Ignores disabled links.
- Parameters
- report -
- [optional] collision report
- Return
- true if a collision occurred
- FindIKSolution((Manipulator)arg1, (object)param, (int)filteroptions[, (bool)ikreturn[, (bool)releasegil]]) → object :¶
bool FindIKSolution(const IkParameterization & param, std::vector< dReal > & solution, int filteroptions)
Find a close solution to the current robot’s joint values.
- Parameters
- param -
- The transformation of the end-effector in the global coord system
- solution -
- Will be of size GetArmIndices().size() and contain the best solution
- filteroptions -
- A bitmask of IkFilterOptions values controlling what is checked for each ik solution. The function is a wrapper around the IkSolver interface. Note that the solution returned is not guaranteed to be the closest solution. In order to compute that, will have to compute all the ik solutions using FindIKSolutions.
FindIKSolution( (Manipulator)arg1, (object)param, (object)freevalues, (int)filteroptions [, (bool)ikreturn [, (bool)releasegil]]) -> object :
bool FindIKSolution(const IkParameterization & param, const std::vector< dReal > & vFreeParameters, std::vector< dReal > & solution, int filteroptions)
- FindIKSolutions((Manipulator)arg1, (object)param, (int)filteroptions[, (bool)ikreturn[, (bool)releasegil]]) → object :¶
bool FindIKSolutions(const IkParameterization & param, std::vector< std::vector< dReal > > & solutions, int filteroptions)
Find all the IK solutions for the given end effector transform.
- Parameters
- param -
- The transformation of the end-effector in the global coord system
- solutions -
- An array of all solutions, each element in solutions is of size GetArmIndices().size()
- filteroptions -
- A bitmask of IkFilterOptions values controlling what is checked for each ik solution.
FindIKSolutions( (Manipulator)arg1, (object)param, (object)freevalues, (int)filteroptions [, (bool)ikreturn [, (bool)releasegil]]) -> object :
bool FindIKSolutions(const IkParameterization & param, const std::vector< dReal > & vFreeParameters, std::vector< std::vector< dReal > > & solutions, int filteroptions)
- GetArmConfigurationSpecification((Manipulator)arg1[, (str)interpolation]) → object :¶
ConfigurationSpecification GetArmConfigurationSpecification(const std::string & interpolation = “” )
return a copy of the configuration specification of the arm indices
Note that the return type is by-value, so should not be used in iteration
- GetArmIndices((Manipulator)arg1) → object :¶
const std::vector< int > & GetArmIndices()
Return the indices of the DOFs of the arm (used for IK, etc).
Usually the DOF indices from pBase to pEndEffector
- GetArmJoints((Manipulator)arg1) → object :¶
const std::vector< int > & GetArmIndices()
Return the indices of the DOFs of the arm (used for IK, etc).
Usually the DOF indices from pBase to pEndEffector
- GetBase((Manipulator)arg1) → object :¶
LinkPtr GetBase()
the base used for the iksolver
- GetChildDOFIndices((Manipulator)arg1) → object :¶
void GetChildDOFIndices(std::vector< int > & vdofndices)
Get all child DOF indices of the manipulator starting at the pEndEffector link.
- GetChildJoints((Manipulator)arg1) → object :¶
void GetChildJoints(std::vector< JointPtr > & vjoints)
Get all child joints of the manipulator starting at the pEndEffector link.
- GetChildLinks((Manipulator)arg1) → object :¶
void GetChildLinks(std::vector< LinkPtr > & vlinks)
Get all child links of the manipulator starting at pEndEffector link.
The child links do not include the arm links.
- GetClosingDirection((Manipulator)arg1) → object :¶
const std::vector< dReal > & GetClosingDirection()
return the normal direction to move joints to ‘close’ the hand
- GetDirection((Manipulator)arg1) → object :¶
Vector GetLocalToolDirection()
direction of palm/head/manipulator used for approaching. defined inside the manipulator/grasp coordinate system
- GetEndEffector((Manipulator)arg1) → object :¶
LinkPtr GetEndEffector()
the end effector link (used to define workspace distance)
- GetEndEffectorTransform((Manipulator)arg1) → object :¶
Transform GetTransform()
Return the transformation of the manipulator frame.
The manipulator frame is defined by the the end effector link position * GetLocalToolTransform() All inverse kinematics and jacobian queries are specifying this frame.
- GetFreeParameters((Manipulator)arg1) → object :¶
bool GetFreeParameters(std::vector< dReal > & vFreeParameters)
gets the free parameters from the current robot configuration
- Parameters
- vFreeParameters -
- is filled with GetNumFreeParameters() parameters in [0,1] range
- Return
- true if succeeded
- GetGraspTransform((Manipulator)arg1) → object :¶
Transform GetLocalToolTransform()
Return transform with respect to end effector defining the grasp coordinate system.
- GetGripperIndices((Manipulator)arg1) → object :¶
const std::vector< int > & GetGripperIndices()
Gripper indices of the joints that the manipulator controls.
- GetGripperJoints((Manipulator)arg1) → object :¶
const std::vector< int > & GetGripperIndices()
Gripper indices of the joints that the manipulator controls.
- GetIkParameterization((Manipulator)arg1, (object)iktype[, (bool)inworld]) → object :¶
IkParameterization GetIkParameterization(const IkParameterization & ikparam, bool inworld = true )
returns a full parameterization of a given IK type for the current manipulator position using an existing IkParameterization as the seed.
- Parameters
- ikparam -
- The parameterization to use as seed.
- inworld -
- if true will return the parameterization in the world coordinate system, otherwise in the base link (GetBase()) coordinate system Custom data is copied to the new parameterization. Furthermore, some IK types like Lookat3D and TranslationLocalGlobal6D set constraints in the global coordinate system of the manipulator. Because these values are not stored in manipulator itself, they have to be passed in through an existing IkParameterization. Ideally pluging the returned ik parameterization into FindIkSolution should return the a manipulator configuration such that a new call to GetIkParameterization returns the same values.
IkParameterization GetIkParameterization(IkParameterizationType iktype, bool inworld = true )
returns the parameterization of a given IK type for the current manipulator position.
- Parameters
- iktype -
- the type of parameterization to request
- inworld -
- if true will return the parameterization in the world coordinate system, otherwise in the base link (GetBase()) coordinate system Ideally pluging the returned ik parameterization into FindIkSolution should return the a manipulator configuration such that a new call to GetIkParameterization returns the same values. In other words:
- GetIkSolver((Manipulator)arg1) → object :¶
IkSolverBasePtr GetIkSolver()
Returns the currently set ik solver.
- GetIndependentLinks((Manipulator)arg1) → object :¶
void GetIndependentLinks(std::vector< LinkPtr > & vlinks)
Get all links that are independent of the arm and gripper joints.
In other words, returns all links not on the path from the base to the end effector and not children of the end effector. The base and all links rigidly attached to it are also returned.
- GetInfo((Manipulator)arg1) → object¶
- GetKinematicsStructureHash((Manipulator)arg1) → str :¶
const std::string & GetKinematicsStructureHash()
Return hash of all kinematics information that involves solving the inverse kinematics equations.
This includes joint axes, joint positions, and final grasp transform. Hash is used to cache the solvers.
- GetLocalToolDirection((Manipulator)arg1) → object :¶
Vector GetLocalToolDirection()
direction of palm/head/manipulator used for approaching. defined inside the manipulator/grasp coordinate system
- GetLocalToolTransform((Manipulator)arg1) → object :¶
Transform GetLocalToolTransform()
Return transform with respect to end effector defining the grasp coordinate system.
- GetName((Manipulator)arg1) → object :¶
const std::string & GetName()
- GetNumFreeParameters((Manipulator)arg1) → int :¶
int GetNumFreeParameters()
Number of free parameters defining the null solution space.
Each parameter is always in the range of [0,1].
- GetPalmDirection((Manipulator)arg1) → object :¶
Vector GetLocalToolDirection()
direction of palm/head/manipulator used for approaching. defined inside the manipulator/grasp coordinate system
- GetRobot((Manipulator)arg1) → Robot :¶
RobotBasePtr GetRobot()
- GetStructureHash((Manipulator)arg1) → str :¶
const std::string & GetStructureHash()
Return hash of just the manipulator definition.
- GetTransform((Manipulator)arg1) → object :¶
Transform GetTransform()
Return the transformation of the manipulator frame.
The manipulator frame is defined by the the end effector link position * GetLocalToolTransform() All inverse kinematics and jacobian queries are specifying this frame.
- GetVelocity((Manipulator)arg1) → object :¶
std::pair< Vector , Vector > GetVelocity()
return the linear/angular velocity of the manipulator coordinate system
- IsChildLink((Manipulator)arg1, (object)arg2) → bool :¶
bool IsChildLink(LinkConstPtr plink)
returns true if a link is part of the child links of the manipulator.
The child links do not include the arm links.
- IsGrabbing((Manipulator)arg1, (KinBody)body) → bool :¶
bool IsGrabbing(KinBodyConstPtr body)
Checks collision with a target body and all the independent links of the robot. Ignores disabled links.
- Parameters
- the -
- body to check the independent links with
- report -
- [optional] collision report
- Return
- true if a collision occurredreturn true if the body is being grabbed by any link on this manipulator
- SetIKSolver((Manipulator)arg1, (IkSolver)arg2) → bool :¶
bool SetIkSolver(IkSolverBasePtr iksolver)
Sets the ik solver and initializes it with the current manipulator.
Due to complications with translation,rotation,direction,and ray ik, the ik solver should take into account the grasp transform (_info._tLocalTool) internally. The actual ik primitives are transformed into the base frame only.
- SetIkSolver((Manipulator)arg1, (IkSolver)arg2) → bool :¶
bool SetIkSolver(IkSolverBasePtr iksolver)
Sets the ik solver and initializes it with the current manipulator.
Due to complications with translation,rotation,direction,and ray ik, the ik solver should take into account the grasp transform (_info._tLocalTool) internally. The actual ik primitives are transformed into the base frame only.
- SetLocalToolTransform((Manipulator)arg1, (object)arg2) → None :¶
void SetLocalToolTransform(const Transform & t)
Sets the local tool transform with respect to the end effector.
Because this call will change manipulator hash, it resets the loaded IK and sets the Prop_RobotManipulatorTool message.
- SetName((Manipulator)arg1, (str)name) → None :¶
void SetName(const std::string & name)
new name for manipulator
- Exceptions
- openrave_exception -
- if name is already used in another manipulator
- class Robot.ManipulatorInfo¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
- Robot.RegrabAll((Robot)arg1) → None :¶
void RegrabAll()
Releases and grabs all bodies, has the effect of recalculating all the initial collision with the bodies.
This has the effect of resetting the current collisions any grabbed body makes with the robot into an ignore list.
- Robot.Release((Robot)arg1, (KinBody)body) → None :¶
void Release(KinBodyPtr body)
Release the body if grabbed.
- Parameters
- body -
- body to release
- Robot.ReleaseAllGrabbed((Robot)arg1) → None :¶
void ReleaseAllGrabbed()
Release all grabbed bodies.
release all bodies
- Robot.RemoveManipulator((Robot)arg1, (Manipulator)manip) → None :¶
void RemoveManipulator(ManipulatorPtr manip)
removes a manipulator from the robot list.
Will change the robot structure hash.. if the active manipulator is set to this manipulator, it will be set to None afterwards
- Robot.ResetGrabbed((Robot)arg1, (object)grabbedinfos) → None¶
- class Robot.RobotStateSaver¶
Bases: Boost.Python.instance
__init__( (object)arg1, (Robot)robot) -> None
__init__( (object)arg1, (Robot)robot, (object)options) -> None
- GetBody((RobotStateSaver)arg1) → object¶
- Release((RobotStateSaver)arg1) → None¶
- Restore((RobotStateSaver)arg1[, (Robot)body]) → None¶
- Robot.SetActiveDOFValues((Robot)arg1, (object)values[, (int)checklimits]) → None :¶
void SetActiveDOFValues(const std::vector< dReal > & values, uint32_t checklimits = 1 )
- Robot.SetActiveDOFVelocities((Robot)arg1, (object)arg2) → None :¶
void SetActiveDOFVelocities(const std::vector< dReal > & velocities, uint32_t checklimits = 1 )
- Robot.SetActiveDOFs((Robot)arg1, (object)dofindices) → None :¶
void SetActiveDOFs(const std::vector< int > & dofindices, int affine = OpenRAVE::DOF_NoTransform )
Set the joint indices and affine transformation dofs that the planner should use. If DOF_RotationAxis is specified, the previously set axis is used.
- Parameters
- dofindices -
- the indices of the original degrees of freedom to use.
- affine -
- A bitmask of DOFAffine values
SetActiveDOFs( (Robot)arg1, (object)dofindices, (int)affine) -> None :
void SetActiveDOFs(const std::vector< int > & dofindices, int affine = OpenRAVE::DOF_NoTransform )
Set the joint indices and affine transformation dofs that the planner should use. If DOF_RotationAxis is specified, the previously set axis is used.
- Parameters
- dofindices -
- the indices of the original degrees of freedom to use.
- affine -
- A bitmask of DOFAffine values
SetActiveDOFs( (Robot)arg1, (object)dofindices, (int)affine, (object)rotationaxis) -> None :
void SetActiveDOFs(const std::vector< int > & dofindices, int affine, const Vector & rotationaxis)
Set the joint indices and affine transformation dofs that the planner should use. If DOF_RotationAxis is specified, then rotationaxis is set as the new axis.
- Parameters
- dofindices -
- the indices of the original degrees of freedom to use.
- affine -
- A bitmask of DOFAffine values
- rotationaxis -
- if DOF_RotationAxis is specified, pRotationAxis is used as the new axis
- Robot.SetActiveManipulator((Robot)arg1, (int)manipindex) → Manipulator :¶
- void SetActiveManipulator(int index)
SetActiveManipulator( (Robot)arg1, (str)manipname) -> Manipulator :
void SetActiveManipulator(const std::string & manipname)
sets the active manipulator of the robot
- Parameters
- manipname -
- manipulator name Exceptions
- openrave_exception -
- if manipulator not present, will throw an exception
- SetActiveManipulator( (Robot)arg1, (Manipulator)manip) -> Manipulator :
- Set the active manipulator given a pointer
- Robot.SetAffineRotation3DLimits((Robot)arg1, (object)lower, (object)upper) → None :¶
void SetAffineRotation3DLimits(const Vector & lower, const Vector & upper)
- Robot.SetAffineRotation3DMaxVels((Robot)arg1, (object)velocity) → None :¶
void SetAffineRotation3DMaxVels(const Vector & vels)
- Robot.SetAffineRotation3DResolution((Robot)arg1, (object)resolution) → None :¶
void SetAffineRotation3DResolution(const Vector & resolution)
- Robot.SetAffineRotation3DWeights((Robot)arg1, (object)weights) → None :¶
void SetAffineRotation3DWeights(const Vector & weights)
- Robot.SetAffineRotationAxisLimits((Robot)arg1, (object)lower, (object)upper) → None :¶
void SetAffineRotationAxisLimits(const Vector & lower, const Vector & upper)
- Robot.SetAffineRotationAxisMaxVels((Robot)arg1, (object)velocity) → None :¶
void SetAffineRotationAxisMaxVels(const Vector & vels)
- Robot.SetAffineRotationAxisResolution((Robot)arg1, (object)resolution) → None :¶
void SetAffineRotationAxisResolution(const Vector & resolution)
- Robot.SetAffineRotationAxisWeights((Robot)arg1, (object)weights) → None :¶
void SetAffineRotationAxisWeights(const Vector & weights)
- Robot.SetAffineRotationQuatLimits((Robot)arg1, (object)quatangle) → None :¶
void SetAffineRotationQuatLimits(const Vector & quatangle)
sets the quaternion limits using a starting rotation and the max angle deviation from it.
- Parameters
- quatangle -
- quaternion_start * max_angle. acos(q dot quaternion_start) <= max_angle. If max_angle is 0, then will take the current transform of the robot
- Robot.SetAffineRotationQuatMaxVels((Robot)arg1, (float)velocity) → None :¶
void SetAffineRotationQuatMaxVels(dReal vels)
- Robot.SetAffineRotationQuatResolution((Robot)arg1, (float)resolution) → None :¶
void SetAffineRotationQuatResolution(dReal resolution)
- Robot.SetAffineRotationQuatWeights((Robot)arg1, (float)weights) → None :¶
void SetAffineRotationQuatWeights(dReal weights)
- Robot.SetAffineTranslationLimits((Robot)arg1, (object)lower, (object)upper) → None :¶
void SetAffineTranslationLimits(const Vector & lower, const Vector & upper)
- Robot.SetAffineTranslationMaxVels((Robot)lower, (object)upper) → None :¶
void SetAffineTranslationMaxVels(const Vector & vels)
- Robot.SetAffineTranslationResolution((Robot)arg1, (object)resolution) → None :¶
void SetAffineTranslationResolution(const Vector & resolution)
- Robot.SetAffineTranslationWeights((Robot)arg1, (object)weights) → None :¶
void SetAffineTranslationWeights(const Vector & weights)
- Robot.SetController((Robot)arg1, (Controller)arg2, (str)arg3) → bool :¶
bool SetController(ControllerBasePtr controller, const std::vector< int > & dofindices, int nControlTransformation)
set a controller for a robot
- Parameters
- pController -
- if NULL, sets the controller of this robot to NULL. otherwise attemps to set the controller to this robot.
- args -
- the argument list to pass when initializing the controller
SetController( (Robot)arg1, (Controller)robot, (object)dofindices, (int)controltransform) -> bool :
bool SetController(ControllerBasePtr controller, const std::vector< int > & dofindices, int nControlTransformation)
set a controller for a robot
- Parameters
- pController -
- if NULL, sets the controller of this robot to NULL. otherwise attemps to set the controller to this robot.
- args -
- the argument list to pass when initializing the controller
SetController( (Robot)arg1, (Controller)arg2) -> bool :
bool SetController(ControllerBasePtr controller, const std::vector< int > & dofindices, int nControlTransformation)
set a controller for a robot
- Parameters
- pController -
- if NULL, sets the controller of this robot to NULL. otherwise attemps to set the controller to this robot.
- args -
- the argument list to pass when initializing the controller
- Robot.SubtractActiveDOFValues((Robot)arg1, (object)values0, (object)values1) → object :¶
void SubtractActiveDOFValues(std::vector< dReal > & q1, const std::vector< dReal > & q2)
computes the configuration difference q1-q2 and stores it in q1. Takes into account joint limits and circular joints
- Robot.WaitForController((Robot)arg1, (float)timeout) → bool :¶
Wait until the robot controller is done
- class openravepy.openravepy_int.SampleDataType¶
Bases: Boost.Python.enum
SampleDataType
- Real = openravepy.openravepy_int.SampleDataType.Real¶
- Uint32 = openravepy.openravepy_int.SampleDataType.Uint32¶
- names = {'Real': openravepy.openravepy_int.SampleDataType.Real, 'Uint32': openravepy.openravepy_int.SampleDataType.Uint32}¶
- values = {1: openravepy.openravepy_int.SampleDataType.Real, 2: openravepy.openravepy_int.SampleDataType.Uint32}¶
- class openravepy.openravepy_int.Sensor¶
Bases: openravepy.openravepy_int.Interface
Raises an exception This class cannot be instantiated from Python
- class ActuatorSensorData¶
Bases: openravepy.openravepy_int.SensorData
Raises an exception This class cannot be instantiated from Python
- appliedcurrent¶
- maxacceleration¶
- maxcurrent¶
- maxjerk¶
- maxtorque¶
- maxvelocity¶
- measuredcurrent¶
- measuredtemperature¶
- nominalcurrent¶
- state¶
- staticfriction¶
- viscousfriction¶
- class Sensor.ActuatorState¶
Bases: Boost.Python.enum
ActuatorState
the state of the actuator- Braked = openravepy.openravepy_int.ActuatorState.Braked¶
- Idle = openravepy.openravepy_int.ActuatorState.Idle¶
- Moving = openravepy.openravepy_int.ActuatorState.Moving¶
- Stalled = openravepy.openravepy_int.ActuatorState.Stalled¶
- Undefined = openravepy.openravepy_int.ActuatorState.Undefined¶
- names = {'Braked': openravepy.openravepy_int.ActuatorState.Braked, 'Idle': openravepy.openravepy_int.ActuatorState.Idle, 'Moving': openravepy.openravepy_int.ActuatorState.Moving, 'Undefined': openravepy.openravepy_int.ActuatorState.Undefined, 'Stalled': openravepy.openravepy_int.ActuatorState.Stalled}¶
- values = {0: openravepy.openravepy_int.ActuatorState.Undefined, 1: openravepy.openravepy_int.ActuatorState.Idle, 2: openravepy.openravepy_int.ActuatorState.Moving, 3: openravepy.openravepy_int.ActuatorState.Stalled, 4: openravepy.openravepy_int.ActuatorState.Braked}¶
- class Sensor.CameraIntrinsics¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
- K¶
- distortion_coeffs¶
- distortion_model¶
- focal_length¶
- class Sensor.CameraSensorData¶
Bases: openravepy.openravepy_int.SensorData
Raises an exception This class cannot be instantiated from Python
- KK¶
- imagedata¶
- transform¶
- Sensor.Configure((Sensor)arg1, (ConfigureCommand)command[, (bool)blocking]) → int :¶
int Configure(ConfigureCommand command, bool blocking = false )
Configures properties of the sensor like power.
- Parameters
- type -
- ConfigureCommand
- blocking -
- If set to true, makes sure the configuration ends before this function returns.(might cause problems if environment is locked). Exceptions
- openrave_exception -
- if command doesn’t succeed
- class Sensor.ConfigureCommand¶
Bases: Boost.Python.enum
ConfigureCommand
A set of commands used for run-time sensor configuration.- PowerCheck = openravepy.openravepy_int.ConfigureCommand.PowerCheck¶
- PowerOff = openravepy.openravepy_int.ConfigureCommand.PowerOff¶
- PowerOn = openravepy.openravepy_int.ConfigureCommand.PowerOn¶
- RenderDataCheck = openravepy.openravepy_int.ConfigureCommand.RenderDataCheck¶
- RenderDataOff = openravepy.openravepy_int.ConfigureCommand.RenderDataOff¶
- RenderDataOn = openravepy.openravepy_int.ConfigureCommand.RenderDataOn¶
- RenderGeometryCheck = openravepy.openravepy_int.ConfigureCommand.RenderGeometryCheck¶
- RenderGeometryOff = openravepy.openravepy_int.ConfigureCommand.RenderGeometryOff¶
- RenderGeometryOn = openravepy.openravepy_int.ConfigureCommand.RenderGeometryOn¶
- names = {'PowerCheck': openravepy.openravepy_int.ConfigureCommand.PowerCheck, 'RenderGeometryCheck': openravepy.openravepy_int.ConfigureCommand.RenderGeometryCheck, 'PowerOff': openravepy.openravepy_int.ConfigureCommand.PowerOff, 'RenderDataCheck': openravepy.openravepy_int.ConfigureCommand.RenderDataCheck, 'RenderDataOff': openravepy.openravepy_int.ConfigureCommand.RenderDataOff, 'RenderGeometryOn': openravepy.openravepy_int.ConfigureCommand.RenderGeometryOn, 'RenderGeometryOff': openravepy.openravepy_int.ConfigureCommand.RenderGeometryOff, 'RenderDataOn': openravepy.openravepy_int.ConfigureCommand.RenderDataOn, 'PowerOn': openravepy.openravepy_int.ConfigureCommand.PowerOn}¶
- values = {32: openravepy.openravepy_int.ConfigureCommand.RenderDataOn, 33: openravepy.openravepy_int.ConfigureCommand.RenderDataOff, 35: openravepy.openravepy_int.ConfigureCommand.RenderDataCheck, 49: openravepy.openravepy_int.ConfigureCommand.RenderGeometryOff, 48: openravepy.openravepy_int.ConfigureCommand.RenderGeometryOn, 50: openravepy.openravepy_int.ConfigureCommand.RenderGeometryCheck, 16: openravepy.openravepy_int.ConfigureCommand.PowerOn, 17: openravepy.openravepy_int.ConfigureCommand.PowerOff, 18: openravepy.openravepy_int.ConfigureCommand.PowerCheck}¶
- class Sensor.Force6DSensorData¶
Bases: openravepy.openravepy_int.SensorData
Raises an exception This class cannot be instantiated from Python
- force¶
- torque¶
- Sensor.GetName((Sensor)arg1) → object :¶
const std::string & GetName()
- Return
- the name of the sensor
- Sensor.GetSensorData((Sensor)arg1) → SensorData :¶
bool GetSensorData(SensorDataPtr psensordata)
Copy the most recent published data of the sensor given the type.
- Parameters
- psensordata -
- A pointer to SensorData returned from CreateSensorData, the plugin will use psensordata->GetType() in order to return the correctly supported type. Once GetSensorData returns, the caller has full unrestricted access to the data. This method is thread safe.
GetSensorData( (Sensor)arg1, (Type)arg2) -> SensorData :
bool GetSensorData(SensorDataPtr psensordata)
Copy the most recent published data of the sensor given the type.
- Parameters
- psensordata -
- A pointer to SensorData returned from CreateSensorData, the plugin will use psensordata->GetType() in order to return the correctly supported type. Once GetSensorData returns, the caller has full unrestricted access to the data. This method is thread safe.
- Sensor.GetSensorGeometry((Sensor)arg1, (Type)arg2) → SensorData :¶
SensorGeometryPtr GetSensorGeometry(SensorType type = ST_Invalid )
Returns the sensor geometry. This method is thread safe.
- Parameters
- type -
- the requested sensor type to create. A sensor can support many types. If type is ST_Invalid, then returns a data structure
- Return
- sensor geometry pointer, use delete to destroy it
- Sensor.GetTransform((Sensor)arg1) → object :¶
Transform GetTransform()
the position of the sensor in the world coordinate system
- class Sensor.IMUSensorData¶
Bases: openravepy.openravepy_int.SensorData
Raises an exception This class cannot be instantiated from Python
- angular_velocity¶
- angular_velocity_covariance¶
- linear_acceleration¶
- linear_acceleration_covariance¶
- rotation¶
- rotation_covariance¶
- class Sensor.JointEncoderSensorData¶
Bases: openravepy.openravepy_int.SensorData
Raises an exception This class cannot be instantiated from Python
- encoderValues¶
- encoderVelocity¶
- resolution¶
- class Sensor.LaserSensorData¶
Bases: openravepy.openravepy_int.SensorData
Raises an exception This class cannot be instantiated from Python
- intensity¶
- positions¶
- ranges¶
- class Sensor.OdometrySensorData¶
Bases: openravepy.openravepy_int.SensorData
Raises an exception This class cannot be instantiated from Python
- angular_velocity¶
- linear_velocity¶
- pose¶
- pose_covariance¶
- targetid¶
- velocity_covariance¶
- class Sensor.SensorData¶
Bases: Boost.Python.instance
Raises an exception This class cannot be instantiated from Python
- stamp¶
- type¶
- Sensor.SetTransform((Sensor)arg1, (object)arg2) → None :¶
void SetTransform(const Transform & trans)
Set the transform of a sensor (global coordinate system).
- Parameters
- trans -
- The transform defining the frame of the sensor. Sensors attached to the robot have their transforms automatically set every time the robot is moved
- Sensor.Supports((Sensor)arg1, (Type)arg2) → bool :¶
bool Supports(SensorType type)
returns true if sensor supports a particular sensor type
- class Sensor.TactileSensorData¶
Bases: openravepy.openravepy_int.SensorData
Raises an exception This class cannot be instantiated from Python
- force_covariance¶
- forces¶
- positions¶
- thickness¶
- class Sensor.Type¶
Bases: Boost.Python.enum
SensorType
- Actuator = openravepy.openravepy_int.Type.Actuator¶
- Camera = openravepy.openravepy_int.Type.Camera¶
- Force6D = openravepy.openravepy_int.Type.Force6D¶
- IMU = openravepy.openravepy_int.Type.IMU¶
- Invalid = openravepy.openravepy_int.Type.Invalid¶
- JointEncoder = openravepy.openravepy_int.Type.JointEncoder¶
- Laser = openravepy.openravepy_int.Type.Laser¶
- Odometry = openravepy.openravepy_int.Type.Odometry¶
- Tactile = openravepy.openravepy_int.Type.Tactile¶
- names = {'JointEncoder': openravepy.openravepy_int.Type.JointEncoder, 'Odometry': openravepy.openravepy_int.Type.Odometry, 'Laser': openravepy.openravepy_int.Type.Laser, 'Invalid': openravepy.openravepy_int.Type.Invalid, 'Camera': openravepy.openravepy_int.Type.Camera, 'IMU': openravepy.openravepy_int.Type.IMU, 'Actuator': openravepy.openravepy_int.Type.Actuator, 'Force6D': openravepy.openravepy_int.Type.Force6D, 'Tactile': openravepy.openravepy_int.Type.Tactile}¶
- values = {0: openravepy.openravepy_int.Type.Invalid, 1: openravepy.openravepy_int.Type.Laser, 2: openravepy.openravepy_int.Type.Camera, 3: openravepy.openravepy_int.Type.JointEncoder, 4: openravepy.openravepy_int.Type.Force6D, 5: openravepy.openravepy_int.Type.IMU, 6: openravepy.openravepy_int.Type.Odometry, 7: openravepy.openravepy_int.Type.Tactile, 8: openravepy.openravepy_int.Type.Actuator}¶
- class openravepy.openravepy_int.SensorSystem¶
Bases: openravepy.openravepy_int.Interface
Raises an exception This class cannot be instantiated from Python
- class openravepy.openravepy_int.SerializableData¶
Bases: openravepy.openravepy_int.UserData
Raises an exception This class cannot be instantiated from Python
- Deserialize((SerializableData)arg1, (str)data) → None¶
- Serialize((SerializableData)arg1, (int)options) → object¶
- class openravepy.openravepy_int.SerializationOptions¶
Bases: Boost.Python.enum
SerializationOptions
serialization options for interfaces- BodyState = openravepy.openravepy_int.SerializationOptions.BodyState¶
- Dynamics = openravepy.openravepy_int.SerializationOptions.Dynamics¶
- Geometry = openravepy.openravepy_int.SerializationOptions.Geometry¶
- Kinematics = openravepy.openravepy_int.SerializationOptions.Kinematics¶
- NamesAndFiles = openravepy.openravepy_int.SerializationOptions.NamesAndFiles¶
- RobotManipulators = openravepy.openravepy_int.SerializationOptions.RobotManipulators¶
- RobotSensors = openravepy.openravepy_int.SerializationOptions.RobotSensors¶
- names = {'NamesAndFiles': openravepy.openravepy_int.SerializationOptions.NamesAndFiles, 'BodyState': openravepy.openravepy_int.SerializationOptions.BodyState, 'Geometry': openravepy.openravepy_int.SerializationOptions.Geometry, 'RobotManipulators': openravepy.openravepy_int.SerializationOptions.RobotManipulators, 'Kinematics': openravepy.openravepy_int.SerializationOptions.Kinematics, 'RobotSensors': openravepy.openravepy_int.SerializationOptions.RobotSensors, 'Dynamics': openravepy.openravepy_int.SerializationOptions.Dynamics}¶
- values = {32: openravepy.openravepy_int.SerializationOptions.RobotSensors, 1: openravepy.openravepy_int.SerializationOptions.Kinematics, 2: openravepy.openravepy_int.SerializationOptions.Dynamics, 4: openravepy.openravepy_int.SerializationOptions.BodyState, 8: openravepy.openravepy_int.SerializationOptions.NamesAndFiles, 64: openravepy.openravepy_int.SerializationOptions.Geometry, 16: openravepy.openravepy_int.SerializationOptions.RobotManipulators}¶
- class openravepy.openravepy_int.SpaceSampler¶
Bases: openravepy.openravepy_int.Interface
Raises an exception This class cannot be instantiated from Python
- GetDOF((SpaceSampler)arg1) → int :¶
int GetDOF()
returns the degrees of freedom of the sampling space
- GetLimits((SpaceSampler)arg1, (SampleDataType)seed) → object :¶
void GetLimits(std::vector< dReal > & vLowerLimit, std::vector< dReal > & vUpperLimit)
returns the minimum and maximum values returned for each dimension (size is GetNumberOfValues())
By default the limits should be in [0,1]^N.
- GetNumberOfValues((SpaceSampler)seed) → int :¶
int GetNumberOfValues()
Dimension of the return samples.
Number of values used to represent the parameterization of the space (>= dof). For example, let a quaternion describe a 3D rotation. The DOF of the space is 3, while the dimension of the returned samples is 4.
- SampleComplete((SpaceSampler)arg1, (SampleDataType)arg2, (int)num, (Interval)interval) → object :¶
void SampleComplete(std::vector< dReal > & samples, size_t num, IntervalType interval = IT_Closed )
returns N samples that best approximate the entire sampling space.
The sampler can fail by returning an array of size 0.
SampleComplete( (SpaceSampler)arg1, (SampleDataType)arg2, (int)num) -> object :
void SampleComplete(std::vector< uint32_t > & samples, size_t num)
returns N samples that best approximate the entire sampling space.
The sampler can fail by returning an array of size 0.
- SampleSequence((SpaceSampler)arg1, (SampleDataType)arg2, (int)num, (Interval)interval) → object :¶
void SampleSequence(std::vector< dReal > & samples, size_t num = 1 , IntervalType interval = IT_Closed )
sequentially sampling returning the next ‘num’ samples
- Parameters
- sample -
- the values of the samples. This is a num*GetNumberOfValues() array.
- num -
- number of samples to return
- interval -
- the sampling intervel for each of the dimensions. The sampler can fail by returning an array of size 0.
SampleSequence( (SpaceSampler)arg1, (SampleDataType)arg2, (int)num) -> object :
void SampleSequence(std::vector< uint32_t > & sample, size_t num = 1 )
sequentially sampling returning the next ‘num’ samples
- Parameters
- sample -
- the values of the samples. This is a num*GetNumberOfValues() array.
- num -
- number of samples to return The sampler can fail by returning an array of size 0.
- SampleSequenceOneReal((SpaceSampler)arg1[, (Interval)interval]) → float¶
- SampleSequenceOneUInt32((SpaceSampler)arg1) → int¶
- SetSeed((SpaceSampler)arg1, (int)seed) → None :¶
void SetSeed(uint32_t seed)
sets a new seed. For sequence samplers, the seed describes the n^th sample to begin at.
- SetSpaceDOF((SpaceSampler)arg1, (int)dof) → None :¶
void SetSpaceDOF(int dof)
Sets the degrees of freedom of the space (note this is different from the parameterization dimension)
- Supports((SpaceSampler)arg1, (SampleDataType)seed) → bool :¶
bool Supports(SampleDataType type)
- class openravepy.openravepy_int.StateRestoreContext¶
Bases: Boost.Python.instance
Raises an exception This class cannot be instantiated from Python
- Close((StateRestoreContext)arg1) → None¶
- GetBody((StateRestoreContext)arg1) → object¶
- Release((StateRestoreContext)arg1) → None¶
- Restore((StateRestoreContext)arg1[, (object)body]) → None¶
- class openravepy.openravepy_int.Trajectory¶
Bases: openravepy.openravepy_int.Interface
Raises an exception This class cannot be instantiated from Python
- GetConfigurationSpecification((Trajectory)arg1) → object :¶
const ConfigurationSpecification & GetConfigurationSpecification()
- GetDuration((Trajectory)arg1) → float¶
- GetNumWaypoints((Trajectory)arg1) → int :¶
size_t GetNumWaypoints()
return the number of waypoints
- GetWaypoint((Trajectory)arg1, (int)index) → object¶
GetWaypoint( (Trajectory)arg1, (int)index, (ConfigurationSpecification)spec) -> object
- GetWaypoints((Trajectory)arg1, (int)startindex, (int)endindex) → object¶
GetWaypoints( (Trajectory)arg1, (int)startindex, (int)endindex, (ConfigurationSpecification)spec) -> object
- Init((Trajectory)arg1, (ConfigurationSpecification)spec) → None :¶
void Init(const ConfigurationSpecification & spec)
- Insert((Trajectory)arg1, (int)index, (object)data) → None :¶
void Insert(size_t index, const std::vector< dReal > & data, bool bOverwrite = false )
Sets/inserts new waypoints in the same configuration specification as the trajectory.
- Parameters
- index -
- The index where to start modifying the trajectory.
- data -
- The data to insert, can represent multiple consecutive waypoints. data.size()/GetConfigurationSpecification().GetDOF() waypoints are added.
- bOverwrite -
- If true, will overwrite the waypoints starting at index, and will insert new waypoints only if end of trajectory is reached. If false, will insert the points before index: a 0 index inserts the new data in the beginning, a GetNumWaypoints() index inserts the new data at the end.
Insert( (Trajectory)arg1, (int)index, (object)data, (bool)overwrite) -> None :
void Insert(size_t index, const std::vector< dReal > & data, bool bOverwrite = false )
Sets/inserts new waypoints in the same configuration specification as the trajectory.
- Parameters
- index -
- The index where to start modifying the trajectory.
- data -
- The data to insert, can represent multiple consecutive waypoints. data.size()/GetConfigurationSpecification().GetDOF() waypoints are added.
- bOverwrite -
- If true, will overwrite the waypoints starting at index, and will insert new waypoints only if end of trajectory is reached. If false, will insert the points before index: a 0 index inserts the new data in the beginning, a GetNumWaypoints() index inserts the new data at the end.
Insert( (Trajectory)arg1, (int)index, (object)data, (ConfigurationSpecification)spec) -> None :
void Insert(size_t index, const std::vector< dReal > & data, const ConfigurationSpecification & spec, bool bOverwrite = false )
Sets/inserts new waypoints in a configuration specification.
- Parameters
- index -
- The index where to start modifying the trajectory.
- data -
- The data to insert, can represent multiple consecutive waypoints. data.size()/GetConfigurationSpecification().GetDOF() waypoints are added.
- spec -
- the specification in which the input data come in. Depending on what data is offered, some values of this trajectory’s specification might not be initialized.
- bOverwrite -
- If true, will overwrite the waypoints starting at index, and will insert new waypoints only if end of trajectory is reached; if the input spec does not overwrite all the data of the trjectory spec, then the original trajectory data will not be overwritten. If false, will insert the points before index: a 0 index inserts the new data in the beginning, a GetNumWaypoints() index inserts the new data at the end.
Insert( (Trajectory)arg1, (int)index, (object)data, (ConfigurationSpecification)spec, (bool)overwrite) -> None :
void Insert(size_t index, const std::vector< dReal > & data, const ConfigurationSpecification & spec, bool bOverwrite = false )
Sets/inserts new waypoints in a configuration specification.
- Parameters
- index -
- The index where to start modifying the trajectory.
- data -
- The data to insert, can represent multiple consecutive waypoints. data.size()/GetConfigurationSpecification().GetDOF() waypoints are added.
- spec -
- the specification in which the input data come in. Depending on what data is offered, some values of this trajectory’s specification might not be initialized.
- bOverwrite -
- If true, will overwrite the waypoints starting at index, and will insert new waypoints only if end of trajectory is reached; if the input spec does not overwrite all the data of the trjectory spec, then the original trajectory data will not be overwritten. If false, will insert the points before index: a 0 index inserts the new data in the beginning, a GetNumWaypoints() index inserts the new data at the end.
- Read((Trajectory)arg1, (str)data, (object)robot) → bool :¶
bool Read(std::istream & I, RobotBaseConstPtr )
- Remove((Trajectory)arg1, (int)startindex, (int)endindex) → None :¶
void Remove(size_t startindex, size_t endindex)
removes a number of waypoints starting at the specified index
- Sample((Trajectory)arg1, (float)time) → object :¶
void Sample(std::vector< dReal > & data, dReal time)
samples a data point on the trajectory at a particular time
- Parameters
- data[out] -
- the sampled point
- time[in] -
- the time to sample
Sample( (Trajectory)arg1, (float)time, (ConfigurationSpecification)spec) -> object :
void Sample(std::vector< dReal > & data, dReal time, const ConfigurationSpecification & spec)
samples a data point on the trajectory at a particular time and returns data for the group specified.
- Parameters
- data[out] -
- the sampled point
- time[in] -
- the time to sample
- spec[in] -
- the specification format to return the data in The default implementation is slow, so interface developers should override it.
- Write((Trajectory)arg1, (object)options) → object :¶
bool Write(std::ostream & O, int options)
- deserialize((Trajectory)arg1, (str)data) → Trajectory :¶
InterfaceBasePtr deserialize(std::istream & I)
initialize the trajectory
- serialize((Trajectory)arg1[, (object)options]) → object :¶
void serialize(std::ostream & O, int options = 0 )
output the trajectory in XML format
- class openravepy.openravepy_int.TriMesh¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
__init__( (object)arg1, (object)vertices, (object)indices) -> None
- indices¶
- vertices¶
- class openravepy.openravepy_int.UserData¶
Bases: Boost.Python.instance
Raises an exception This class cannot be instantiated from Python
- Close((UserData)arg1) → None :¶
force releasing the user handle point.
- close((UserData)arg1) → None :¶
deprecated
- class openravepy.openravepy_int.Viewer¶
Bases: openravepy.openravepy_int.Interface
Raises an exception This class cannot be instantiated from Python
- EnvironmentSync((Viewer)arg1) → None :¶
void EnvironmentSync()
forces synchronization with the environment, returns when the environment is fully synchronized.
Note that this method might not work if environment is locked in current thread
- GetCameraImage((Viewer)arg1, (int)width, (int)height, (object)transform, (object)K) → object :¶
bool GetCameraImage(std::vector< uint8_t > & memory, int width, int height, const RaveTransform < float > & t, const SensorBase::CameraIntrinsics & intrinsics)
Renders a 24bit RGB image of dimensions width and height from the current scene.
- Parameters
- memory -
- the memory where the image will be stored at, has to store 3*width*height
- width -
- width of the image, if 0 the width of the viewer is used
- height -
- height of the image, if 0 the width of the viewer is used
- t -
- the rotation and translation of the camera. Note that +z is treated as the camera direction axis! So all points in front of the camera have a positive dot product with its +z direction.
- intrinsics -
- the intrinsic parameters of the camera defining FOV, distortion, principal point, and focal length. The focal length is used to define the near plane for culling. The camera is meant to show the underlying OpenRAVE world as a robot would see it, so all graphs rendered with the plotX and drawX functions are hidden by default. Some viewers support the SetFiguresInCamera command to allow graphs to be also displayed.
- GetCameraTransform((Viewer)arg1) → object :¶
RaveTransform < float > GetCameraTransform()
Return the current camera transform that the viewer is rendering the environment at.
- GetName((Viewer)arg1) → str :¶
const std::string & GetName()
- Move((Viewer)arg1, (int)arg2, (int)arg3) → None :¶
void Move(int x, int y)
- RegisterCallback((Viewer)arg1, (object)arg2, (object)callback) → object :¶
UserDataPtr RegisterItemSelectionCallback(const ItemSelectionCallbackFn & fncallback)
registers a function with the viewer that gets called everytime mouse button is clicked
- Return
- a handle to the callback. If this handle is deleted, the callback will be unregistered.
- RegisterItemSelectionCallback((Viewer)arg1, (object)callback) → object :¶
UserDataPtr RegisterItemSelectionCallback(const ItemSelectionCallbackFn & fncallback)
registers a function with the viewer that gets called everytime mouse button is clicked
- Return
- a handle to the callback. If this handle is deleted, the callback will be unregistered.
- SetBkgndColor((Viewer)arg1, (object)arg2) → None :¶
void SetBkgndColor(const RaveVector< float > & color)
- SetCamera((Viewer)arg1, (object)transform) → None :¶
void SetCamera(const RaveTransform < float > & trans, float focalDistance = 0 )
Set the camera transformation.
- Parameters
- trans -
- new camera transformation in the world coordinate system
- focalDistance -
- The new focal distance of the camera (higher values is higher zoom). If 0, then the previous focal distance is preserved.
SetCamera( (Viewer)arg1, (object)transform, (float)focalDistance) -> None :
void SetCamera(const RaveTransform < float > & trans, float focalDistance = 0 )
Set the camera transformation.
- Parameters
- trans -
- new camera transformation in the world coordinate system
- focalDistance -
- The new focal distance of the camera (higher values is higher zoom). If 0, then the previous focal distance is preserved.
- SetName((Viewer)arg1, (str)arg2) → None :¶
void SetName(const std::string & name)
- SetSize((Viewer)arg1, (int)arg2, (int)arg3) → None :¶
void SetSize(int w, int h)
- SetTitle((Viewer)arg1, (str)arg2) → None :¶
void SetName(const std::string & name)
- main((Viewer)arg1, (bool)show[, (int)sig_thread_id]) → int :¶
int main(bool bShow = true )
goes into the main loop
- Parameters
- bShow -
- if true will show the window
- quitmainloop((Viewer)arg1) → None :¶
void quitmainloop()
destroys the main loop
- class openravepy.openravepy_int.VoidHandle¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
- Close((VoidHandle)arg1) → None¶
- close((VoidHandle)arg1) → None :¶
deprecated
- class openravepy.openravepy_int.VoidPointer¶
Bases: Boost.Python.instance
Holds auto-managed resources, deleting it releases its shared data.
__init__( (object)arg1) -> None
- class openravepy.openravepy_int.XMLReadable¶
Bases: Boost.Python.instance
__init__( (object)arg1, (object)readableraw) -> None
- GetXMLId((XMLReadable)arg1) → str¶
- Serialize((XMLReadable)arg1[, (int)options]) → object¶
- openravepy.openravepy_int.axisAngleFromQuat((object)quat) → object :¶
RaveVector < T > axisAngleFromQuat(const RaveVector < T > & quat)
Converts a quaternion into the axis-angle representation.
- Parameters
- quat -
- quaternion, (s,vx,vy,vz)
- openravepy.openravepy_int.axisAngleFromRotationMatrix((object)rotation) → object :¶
RaveVector < T > axisAngleFromMatrix(const RaveTransformMatrix < T > & rotation)
Converts the rotation of a matrix into axis-angle representation.
- Parameters
- rotation -
- 3x3 rotation matrix
- openravepy.openravepy_int.invertPoses((object)poses) → object :¶
Inverts a Nx7 array of poses where first 4 columns are the quaternion and last 3 are the translation components.
Parameters: poses – nx7 array
- openravepy.openravepy_int.matrixFromAxisAngle((object)axisangle) → object :¶
RaveTransformMatrix < T > matrixFromAxisAngle(const RaveVector < T > & axisangle)
Converts an axis-angle rotation to a 3x3 matrix.
- Parameters
- axis -
- unit axis * rotation angle (radians), 3 values
matrixFromAxisAngle( (object)axis, (float)angle) -> object
- openravepy.openravepy_int.matrixFromPose((object)pose) → object :¶
Converts a 7 element quaterion+translation transform to a 4x4 matrix.
Parameters: pose – 7 values
- openravepy.openravepy_int.matrixFromPoses((object)poses) → object :¶
Converts a Nx7 element quaterion+translation array to a 4x4 matrices.
Parameters: poses – nx7 array
- openravepy.openravepy_int.matrixFromQuat((object)quat) → object :¶
Converts a quaternion to a 4x4 affine matrix.
Parameters: quat – 4 values
- openravepy.openravepy_int.matrixSerialization((object)transform) → str :¶
Serializes a transformation into a string representing a 3x4 matrix.
Parameters: transform – 3x4 or 4x4 array
- openravepy.openravepy_int.normalizeAxisRotation((object)axis, (object)quat) → object :¶
std::pair< T, RaveVector < T > > normalizeAxisRotation(const RaveVector < T > & axis, const RaveVector < T > & quat)
Find the rotation theta around axis such that rot(axis,theta) * q is closest to the identity rotation.
- Parameters
- axis -
- axis to minimize rotation about
- quat -
- input
- Return
- The angle that minimizes the rotation along with the normalized rotation rot(axis,theta)*q
- openravepy.openravepy_int.openravepyCompilerVersion() → str :¶
Returns the compiler version that openravepy_int was compiled with
- class openravepy.openravepy_int.options¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
- returnTransformQuaternion = False¶
- class openravepy.openravepy_int.planningutils¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
- class ActiveDOFTrajectoryRetimer¶
Bases: Boost.Python.instance
__init__( (object)robot, (Robot)hastimestamps, (str)plannername, (str)plannerparameters) -> None
- PlanPath((ActiveDOFTrajectoryRetimer)arg1, (Trajectory)traj[, (bool)hastimestamps[, (bool)releasegil]]) → PlannerStatus¶
- class planningutils.ActiveDOFTrajectorySmoother¶
Bases: Boost.Python.instance
__init__( (object)arg1, (Robot)robot, (str)plannername, (str)plannerparameters) -> None
- PlanPath((ActiveDOFTrajectorySmoother)arg1, (Trajectory)traj[, (bool)releasegil]) → PlannerStatus¶
- class planningutils.AffineTrajectoryRetimer¶
Bases: Boost.Python.instance
__init__( (object)arg1, (str)plannername, (str)plannerparameters) -> None
- PlanPath((AffineTrajectoryRetimer)arg1, (Trajectory)traj, (object)maxvelocities, (object)maxaccelerations[, (bool)hastimestamps[, (bool)releasegil]]) → PlannerStatus¶
- planningutils.ComputeTrajectoryDerivatives((Trajectory)trajectory, (int)maxderiv) → None :¶
OPENRAVE_API void ComputeTrajectoryDerivatives(TrajectoryBasePtr traj, int maxderiv)
computes the trajectory derivatives and modifies the trajetory configuration to store them.
- Parameters
- traj -
- the re-timed trajectory
- maxderiv -
- the maximum derivative to assure. If 1, will assure velocities, if 2 will assure accelerations, etc. If necessary will change the configuration specification of the trajectory. If more derivatives are requested than the trajectory supports, will ignore them. For example, acceleration of a linear trajectory.
- planningutils.ConvertTrajectorySpecification((Trajectory)trajectory, (ConfigurationSpecification)spec) → None :¶
OPENRAVE_API void ConvertTrajectorySpecification(TrajectoryBasePtr traj, const ConfigurationSpecification & spec)
convert the trajectory and all its points to a new specification
- class planningutils.DHParameter¶
Bases: Boost.Python.instance
__init__( (object)arg1) -> None
__init__( (object)arg1) -> None
__init__( (object)arg1, (object)joint, (int)parentindex, (object)transform, (float)d, (float)a, (float)theta, (float)alpha) -> None
- a¶
- alpha¶
- d¶
- joint¶
- parentindex¶
- theta¶
- transform¶
- planningutils.GetDHParameters((KinBody)body) → list :¶
OPENRAVE_API void GetDHParameters(std::vector< DHParameter > & vparameters, KinBodyConstPtr pbody)
returns the Denavit-Hartenberg parameters of the kinematics structure of the body.
- Parameters
- vparameters -
- One set of parameters are returned for each joint. Parameters
- tstart -
- the initial transform in the body coordinate system to the first joint If the robot has joints that cannot be represented by DH, will throw an exception. Passive joints are ignored. Joints are ordered by hierarchy dependency. By convention N joints give N-1 DH parameters, but GetDHParameters returns N parameters. The reason is because the first parameter is used to define the coordinate system of the first axis relative to the robot origin.
- Note
- The coordinate systems computed from the DH parameters do not match the OpenRAVE link coordinate systems.
- See
- DHParameter.
- planningutils.InsertWaypointWithSmoothing((int)index, (object)dofvalues, (object)dofvelocities, (Trajectory)trajectory[, (float)maxvelmult[, (float)maxaccelmult[, (str)plannername]]]) → None :¶
OPENRAVE_API void InsertWaypointWithSmoothing(int index, const std::vector< dReal > & dofvalues, const std::vector< dReal > & dofvelocities, TrajectoryBasePtr traj, dReal fmaxvelmult = 1 , dReal fmaxaccelmult = 1 , const std::string & plannername = “” )
insert a waypoint in a timed trajectory and smooth so that the trajectory always goes through the waypoint at the specified velocity.
- Parameters
- index -
- The index where to insert the new waypoint. A negative value starts from the end.
- dofvalues -
- the configuration to insert into the trajectcory (active dof values of the robot)
- dofvelocities -
- the velocities that the inserted point should start with
- traj -
- the trajectory that initially contains the input points, it is modified to contain the new re-timed data.
- plannername -
- the name of the planner to use to smooth. If empty, will use the default trajectory smoother. The PlannerParameters is automatically determined from the trajectory’s configuration space
- planningutils.JitterTransform((KinBody)body, (float)jitter[, (int)maxiterations]) → bool¶
- class planningutils.ManipulatorIKGoalSampler¶
Bases: Boost.Python.instance
__init__( (object)arg1, (object)manip, (object)parameterizations [, (int)nummaxsamples [, (int)nummaxtries [, (float)jitter [, (bool)searchfreeparameters]]]]) -> None
- Sample((ManipulatorIKGoalSampler)arg1[, (bool)ikreturn[, (bool)releasegil]]) → object¶
- SampleAll((ManipulatorIKGoalSampler)arg1[, (int)maxsamples[, (int)maxchecksamples[, (bool)releasegil]]]) → object¶
- planningutils.MergeTrajectories((object)trajectories) → object :¶
OPENRAVE_API TrajectoryBasePtr MergeTrajectories(const std::list< TrajectoryBaseConstPtr > & listtrajectories)
merges the contents of multiple trajectories into one so that everything can be played simultaneously.
- Exceptions
- openrave_exception -
- throws an exception if the trajectory data is incompatible and cannot be merged. Each trajectory needs to have a ‘deltatime’ group for timestamps. The trajectories cannot share common configuration data because only one trajectories’s data can be set at a time.
- planningutils.RetimeActiveDOFTrajectory((Trajectory)trajectory, (Robot)robot[, (bool)hastimestamps[, (float)maxvelmult[, (float)maxaccelmult[, (str)plannername[, (str)plannerparameters]]]]]) → PlannerStatus :¶
OPENRAVE_API void RetimeActiveDOFTrajectory(TrajectoryBasePtr traj, RobotBasePtr robot, bool hastimestamps = false , dReal fmaxvelmult = 1 , dReal fmaxaccelmult = 1 , const std::string & plannername = “” , const std::string & plannerparameters = “” )
Retime the trajectory points by extracting and using the currently set active dofs of the robot.
- Parameters
- traj -
- the trajectory that initially contains the input points, it is modified to contain the new re-timed data.
- robot -
- use the robot’s active dofs to initialize the trajectory space
- plannername -
- the name of the planner to use to retime. If empty, will use the default trajectory re-timer.
- hastimestamps -
- if true, use the already initialized timestamps of the trajectory
- plannerparameters -
- XML string to be appended to PlannerBase::PlannerParameters::_sExtraParameters passed in to the planner. Collision is not checked. Every waypoint in the trajectory is guaranteed to be hit. The velocities for the current trajectory are overwritten. The returned trajectory will contain data only for the currenstly set active dofs of the robot.
- planningutils.RetimeAffineTrajectory((Trajectory)trajectory, (object)maxvelocities, (object)maxaccelerations[, (bool)hastimestamps[, (str)plannername[, (str)plannerparameters]]]) → PlannerStatus :¶
OPENRAVE_API void RetimeAffineTrajectory(TrajectoryBasePtr traj, const std::vector< dReal > & maxvelocities, const std::vector< dReal > & maxaccelerations, bool hastimestamps = false , const std::string & plannername = “” , const std::string & plannerparameters = “” )
Retime the trajectory points consisting of affine transformation values while avoiding collisions.
- Parameters
- traj -
- the trajectory that initially contains the input points, it is modified to contain the new re-timed data.
- maxvelocities -
- the max velocities of each dof
- maxaccelerations -
- the max acceleration of each dof
- plannername -
- the name of the planner to use to retime. If empty, will use the default trajectory re-timer.
- hastimestamps -
- if true, use the already initialized timestamps of the trajectory
- plannerparameters -
- XML string to be appended to PlannerBase::PlannerParameters::_sExtraParameters passed in to the planner. Collision is not checked. Every waypoint in the trajectory is guaranteed to be hit. The velocities for the current trajectory are overwritten.
- planningutils.RetimeTrajectory((Trajectory)trajectory[, (bool)hastimestamps[, (float)maxvelmult[, (float)maxaccelmult[, (str)plannername[, (str)plannerparameters]]]]]) → PlannerStatus :¶
OPENRAVE_API void RetimeTrajectory(TrajectoryBasePtr traj, bool hastimestamps = false , dReal fmaxvelmult = 1 , dReal fmaxaccelmult = 1 , const std::string & plannername = “” , const std::string & plannerparameters = “” )
Retime the trajectory points using all the positional data from the trajectory.
- Parameters
- traj -
- the trajectory that initially contains the input points, it is modified to contain the new re-timed data.
- plannername -
- the name of the planner to use to retime. If empty, will use the default trajectory re-timer.
- hastimestamps -
- if true, use the already initialized timestamps of the trajectory
- plannerparameters -
- XML string to be appended to PlannerBase::PlannerParameters::_sExtraParameters passed in to the planner. Collision is not checked. Every waypoint in the trajectory is guaranteed to be hit. The velocities for the current trajectory are overwritten. The returned trajectory will contain data only for the currenstly set active dofs of the robot.
- planningutils.ReverseTrajectory((Trajectory)trajectory) → object :¶
OPENRAVE_API TrajectoryBasePtr ReverseTrajectory(TrajectoryBaseConstPtr traj)
returns a new trajectory with the order of the waypoints and times reversed.
Velocities are just negated and the new trajectory is not guaranteed to be executable or valid
- planningutils.SmoothActiveDOFTrajectory((Trajectory)trajectory, (Robot)robot[, (float)maxvelmult[, (float)maxaccelmult[, (str)plannername[, (str)plannerparameters]]]]) → PlannerStatus :¶
OPENRAVE_API void SmoothActiveDOFTrajectory(TrajectoryBasePtr traj, RobotBasePtr robot, dReal fmaxvelmult = 1 , dReal fmaxaccelmult = 1 , const std::string & plannername = “” , const std::string & plannerparameters = “” )
Smooth the trajectory points to avoiding collisions by extracting and using the currently set active dofs of the robot.
- Parameters
- traj -
- the trajectory that initially contains the input points, it is modified to contain the new re-timed data.
- robot -
- use the robot’s active dofs to initialize the trajectory space
- plannername -
- the name of the planner to use to smooth. If empty, will use the default trajectory re-timer.
- hastimestamps -
- if true, use the already initialized timestamps of the trajectory
- plannerparameters -
- XML string to be appended to PlannerBase::PlannerParameters::_sExtraParameters passed in to the planner. Only initial and goal configurations are preserved. The velocities for the current trajectory are overwritten. The returned trajectory will contain data only for the currenstly set active dofs of the robot.
- planningutils.SmoothAffineTrajectory((Trajectory)trajectory, (object)maxvelocities, (object)maxaccelerations[, (str)plannername[, (str)plannerparameters]]) → PlannerStatus :¶
OPENRAVE_API void SmoothAffineTrajectory(TrajectoryBasePtr traj, const std::vector< dReal > & maxvelocities, const std::vector< dReal > & maxaccelerations, const std::string & plannername = “” , const std::string & plannerparameters = “” )
Smooth the trajectory points consisting of affine transformation values while avoiding collisions.
- Parameters
- traj -
- the trajectory that initially contains the input points, it is modified to contain the new re-timed data.
- maxvelocities -
- the max velocities of each dof
- maxaccelerations -
- the max acceleration of each dof
- plannername -
- the name of the planner to use to smooth. If empty, will use the default trajectory re-timer.
- hastimestamps -
- if true, use the already initialized timestamps of the trajectory
- plannerparameters -
- XML string to be appended to PlannerBase::PlannerParameters::_sExtraParameters passed in to the planner. Only initial and goal configurations are preserved.
- planningutils.SmoothTrajectory((Trajectory)trajectory[, (float)maxvelmult[, (float)maxaccelmult[, (str)plannername[, (str)plannerparameters]]]]) → PlannerStatus :¶
OPENRAVE_API void SmoothTrajectory(TrajectoryBasePtr traj, dReal fmaxvelmult = 1 , dReal fmaxaccelmult = 1 , const std::string & plannername = “” , const std::string & plannerparameters = “” )
Smooth the trajectory points to avoiding collisions by extracting and using the positional data from the trajectory.
- Parameters
- traj -
- the trajectory that initially contains the input points, it is modified to contain the new re-timed data.
- plannername -
- the name of the planner to use to smooth. If empty, will use the default trajectory re-timer.
- hastimestamps -
- if true, use the already initialized timestamps of the trajectory
- plannerparameters -
- XML string to be appended to PlannerBase::PlannerParameters::_sExtraParameters passed in to the planner. Only initial and goal configurations are preserved. The velocities for the current trajectory are overwritten. The returned trajectory will contain data only for the currenstly set active dofs of the robot.
- planningutils.VerifyTrajectory((object)parameters, (Trajectory)trajectory, (float)samplingstep) → None :¶
void VerifyTrajectory(TrajectoryBaseConstPtr trajectory, dReal samplingstep)
- openravepy.openravepy_int.poseFromMatrices((object)transforms) → object :¶
Converts an array/list of 4x4 matrices to a Nx7 array where each row is quaternion+translation representation.
Parameters: transforms – list of 3x4 or 4x4 affine matrices
- openravepy.openravepy_int.poseFromMatrix((object)transform) → object :¶
Converts a 4x4 matrix to a 7 element quaternion+translation representation.
Parameters: transform – 3x4 or 4x4 affine matrix
- openravepy.openravepy_int.poseMult((object)pose1, (object)pose2) → object :¶
multiplies two poses.
Parameters: - pose1 – 7 values
- pose2 – 7 values
- openravepy.openravepy_int.poseSerialization((object)pose) → str :¶
Serializes a transformation into a string representing a quaternion with translation.
Parameters: pose – 7 values
- openravepy.openravepy_int.poseTransformPoints((object)pose, (object)points) → object :¶
left-transforms a set of points by a pose transformation.
Parameters: - pose – 7 values
- points – Nx3 values
- openravepy.openravepy_int.quatFromAxisAngle((object)axisangle) → object :¶
RaveVector < T > quatFromAxisAngle(const RaveVector < T > & axisangle)
Converts an axis-angle rotation into a quaternion.
- Parameters
- axisangle -
- unit axis * rotation angle (radians), 3 values
quatFromAxisAngle( (object)axis, (float)angle) -> object :
RaveVector < T > quatFromAxisAngle(const RaveVector < T > & axis, T angle)
Converts an axis-angle rotation into a quaternion.
- Parameters
- axis -
- unit axis, 3 values
- angle -
- rotation angle (radians)
- openravepy.openravepy_int.quatFromRotationMatrix((object)rotation) → object :¶
RaveVector < T > quatFromMatrix(const RaveTransformMatrix < T > & rotation)
Converts the rotation of a matrix into a quaternion.
- Parameters
- t -
- transform for extracting the 3x3 rotation.
- openravepy.openravepy_int.quatInverse((object)quat) → object :¶
RaveVector < T > quatInverse(const RaveVector < T > & quat)
Inverted a quaternion rotation.
- Parameters
- quat -
- quaternion, (s,vx,vy,vz)
- openravepy.openravepy_int.quatMult((object)quat0, (object)quat1) → object :¶
RaveVector < T > quatMultiply(const RaveVector < T > & quat0, const RaveVector < T > & quat1)
Multiply two quaternions.
- Parameters
- quat0 -
- quaternion, (s,vx,vy,vz)
- quat1 -
- quaternion, (s,vx,vy,vz)
- openravepy.openravepy_int.quatMultiply((object)quat0, (object)quat1) → object :¶
RaveVector < T > quatMultiply(const RaveVector < T > & quat0, const RaveVector < T > & quat1)
Multiply two quaternions.
- Parameters
- quat0 -
- quaternion, (s,vx,vy,vz)
- quat1 -
- quaternion, (s,vx,vy,vz)
- openravepy.openravepy_int.quatRotateDirection((object)arg1, (object)sourcedir, targetdir) → object :¶
RaveVector < T > quatRotateDirection(const RaveVector < T > & sourcedir, const RaveVector < T > & targetdir)
Return the minimal quaternion that orients sourcedir to targetdir.
- Parameters
- sourcedir -
- direction of the original vector, 3 values
- targetdir -
- new direction, 3 values
- openravepy.openravepy_int.quatSlerp((object)quat0, (object)quat1, (float)t) → object :¶
RaveVector < T > quatSlerp(const RaveVector < T > & quat0, const RaveVector < T > & quat1, T t)
Sphereical linear interpolation between two quaternions.
- Parameters
- quat0 -
- quaternion, (s,vx,vy,vz)
- quat1 -
- quaternion, (s,vx,vy,vz)
- t -
- real value in [0,1]. 0 returns quat1, 1 returns quat2
- openravepy.openravepy_int.raveGetDebugLevel() → int :¶
OPENRAVE_API int RaveGetDebugLevel()
Returns the openrave debug level.
- openravepy.openravepy_int.raveLog((str)log, (int)level) → None :¶
Send a log to the openrave system with excplicit level
- openravepy.openravepy_int.raveLogDebug((str)log) → None :¶
Send a debug log to the openrave system
- openravepy.openravepy_int.raveLogError((str)log) → None :¶
Send an error log to the openrave system
- openravepy.openravepy_int.raveLogFatal((str)log) → None :¶
Send a fatal log to the openrave system
- openravepy.openravepy_int.raveLogInfo((str)log) → None :¶
Send an info log to the openrave system
- openravepy.openravepy_int.raveLogVerbose((str)log) → None :¶
Send a verbose log to the openrave system
- openravepy.openravepy_int.raveLogWarn((str)log) → None :¶
Send a warn log to the openrave system
- openravepy.openravepy_int.raveSetDebugLevel((object)level) → None :¶
OPENRAVE_API void RaveSetDebugLevel(int level)
Sets the global openrave debug level. A combination of DebugLevel.
- openravepy.openravepy_int.rotationMatrixFromAxisAngle((object)axisangle) → object :¶
RaveTransformMatrix < T > matrixFromAxisAngle(const RaveVector < T > & axisangle)
Converts an axis-angle rotation to a 3x3 matrix.
- Parameters
- axis -
- unit axis * rotation angle (radians), 3 values
rotationMatrixFromAxisAngle( (object)axis, (float)angle) -> object
- openravepy.openravepy_int.rotationMatrixFromQArray((object)quatarray) → object :¶
Converts an array of quaternions to a list of 3x3 rotation matrices.
Parameters: quatarray – nx4 array
- openravepy.openravepy_int.rotationMatrixFromQuat((object)quat) → object :¶
RaveTransformMatrix < T > matrixFromQuat(const RaveVector < T > & quat)
Converts a quaternion to a 3x3 matrix.
- Parameters
- quat -
- quaternion, (s,vx,vy,vz)
- openravepy.openravepy_int.transformLookat((object)lookat, (object)camerapos, (object)cameraup) → object :¶
Returns a camera matrix that looks along a ray with a desired up vector.
Parameters: - lookat – unit axis, 3 values
- camerapos – 3 values
- cameraup – unit axis, 3 values
Questions/Feedback
Having problems with OpenRAVE?
- Search for information in the archives of the openrave-users mailing list, or post a question.
- If you notice errors , please open a ticket and let us know!