OpenRAVE Documentation

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 data

SetUserData( (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 data

SetUserData( (Interface)arg1, (object)data) -> None :

void SetUserData(UserDataPtr data)

set user data

SetUserData( (Interface)arg1, (str)key, (UserData)data) -> None :

void SetUserData(UserDataPtr data)

set user data

SetUserData( (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

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

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.

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.

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

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

LinkPtr GetHierarchyChildLink()

Return the child link whose transformation is computed by this joint’s values (either GetFirstAttached() or GetSecondAttached())

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

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.
GeomProperties

alias of Geometry

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.

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

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

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

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

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.

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.

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

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
class openravepy.openravepy_int.xmlreaders

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

CreateStringXMLReadable((str)xmlid, (str)data) → XMLReadable

Questions/Feedback

Having problems with OpenRAVE?