OpenRAVE Documentation

openravepy_int Module

class openravepy.openravepy_int.AABB

Bases: Boost.Python.instance

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

GetCollisionOptions((CollisionChecker)arg1) → int :

int GetCollisionOptions()

get the current collision options
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

contacts
minDistance
numCols
numWithinTol
options
plink1
plink2
class openravepy.openravepy_int.ConfigurationSpecification

Bases: Boost.Python.instance

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
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)

adds a velocity group for every position group.

Parameters
adddeltatime -
If true will add the ‘deltatime’ tag, which is necessary for trajectory sampling If velocities 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.
ExtractDeltaTime((ConfigurationSpecification)arg1, (planningutils)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, (planningutils)data, (KinBody)body, (planningutils)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
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.
class Group

Bases: Boost.Python.instance

dof
interpolation
name
offset
ConfigurationSpecification.InsertDeltaTime((ConfigurationSpecification)arg1, (planningutils)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.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.

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

depth
norm
pos
class openravepy.openravepy_int.Controller

Bases: openravepy.openravepy_int.Interface

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::string & args)

Initializes the controller.

Parameters
robot -
the robot that uses the controller
args -
extra arguments that the controller takes.
Return
true on successful initialization

Init( (Controller)arg1, (Robot)robot, (planningutils)dofindices, (int)controltransform) -> bool :

bool Init(RobotBasePtr robot, const std::string & args)

Initializes the controller.

Parameters
robot -
the robot that uses the controller
args -
extra arguments that the controller takes.
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)arg2) → None :

void Reset(int options)

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, (planningutils)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, (planningutils)values, (planningutils)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
RotationQuat = openravepy.openravepy_int.DOFAffine.RotationQuat
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, '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, 16: openravepy.openravepy_int.DOFAffine.Rotation3D}
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

AddKinBody((Environment)arg1, (KinBody)body) → None :

void AddKinBody(KinBodyPtr body, bool bAnonymous = false )

Add a body to the environment.

Parameters
body -
the pointer to an initialized body
bAnonymous -
if true and there exists a body/robot with the same name, will make body’s name unique Exceptions
openrave_exception -
Throw if body is invalid or already added

AddKinBody( (Environment)arg1, (KinBody)body, (bool)anonymous) -> None :

void AddKinBody(KinBodyPtr body, bool bAnonymous = false )

Add a body to the environment.

Parameters
body -
the pointer to an initialized body
bAnonymous -
if true and there exists a body/robot with the same name, will make body’s name unique Exceptions
openrave_exception -
Throw if body is invalid or already added
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 )

add a robot to the environment

Parameters
robot -
the pointer to an initialized robot
bAnonymous -
if true and there exists a body/robot with the same name, will make robot’s name unique Exceptions
openrave_exception -
Throw if robot is invalid or already added

AddRobot( (Environment)arg1, (Robot)robot, (bool)anonymous) -> None :

void AddRobot(RobotBasePtr robot, bool bAnonymous = false )

add a robot to the environment

Parameters
robot -
the pointer to an initialized robot
bAnonymous -
if true and there exists a body/robot with the same name, will make robot’s name unique Exceptions
openrave_exception -
Throw if robot is invalid or already added
AddSensor((Environment)arg1, (Sensor)sensor) → None :

void AddSensor(SensorBasePtr sensor, bool bAnonymous = false )

registers the sensor with the environment and turns its power on.

Parameters
sensor -
the pointer to an initialized sensor
bAnonymous -
if true and there exists a sensor with the same name, will make sensor’s name unique Exceptions
openrave_exception -
Throw if sensor is invalid or already added

AddSensor( (Environment)arg1, (Sensor)sensor, (bool)anonymous) -> None :

void AddSensor(SensorBasePtr sensor, bool bAnonymous = false )

registers the sensor with the environment and turns its power on.

Parameters
sensor -
the pointer to an initialized sensor
bAnonymous -
if true and there exists a sensor with the same name, will make sensor’s name unique Exceptions
openrave_exception -
Throw if sensor is invalid or already added
AddViewer((Environment)arg1, (Sensor)sensor, (bool)anonymous) → None :

void AddViewer(ViewerBasePtr pviewer)

adds a viewer to the environment

Exceptions
openrave_exception -
Throw if body is invalid or already added
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, (planningutils)link) -> bool :

bool CheckCollision(KinBody::LinkConstPtr plink, CollisionReportPtr report = CollisionReportPtr () )

See
CollisionCheckerBase::CheckCollision(KinBody::LinkConstPtr,CollisionReportPtr)

CheckCollision( (Environment)arg1, (planningutils)link, (CollisionReport)report) -> bool :

bool CheckCollision(KinBody::LinkConstPtr plink, CollisionReportPtr report = CollisionReportPtr () )

See
CollisionCheckerBase::CheckCollision(KinBody::LinkConstPtr,CollisionReportPtr)

CheckCollision( (Environment)arg1, (planningutils)link1, (planningutils)link2) -> bool :

bool CheckCollision(KinBody::LinkConstPtr plink1, KinBody::LinkConstPtr plink2, CollisionReportPtr report = CollisionReportPtr () )

See
CollisionCheckerBase::CheckCollision(KinBody::LinkConstPtr,KinBody::LinkConstPtr,CollisionReportPtr)

CheckCollision( (Environment)arg1, (planningutils)link1, (planningutils)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, (planningutils)link, (KinBody)body) -> bool :

bool CheckCollision(KinBody::LinkConstPtr plink, KinBodyConstPtr pbody, CollisionReportPtr report = CollisionReportPtr () )

See
CollisionCheckerBase::CheckCollision(KinBody::LinkConstPtr,KinBodyConstPtr,CollisionReportPtr)

CheckCollision( (Environment)arg1, (planningutils)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, (planningutils)link, (planningutils)bodyexcluded, (planningutils)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, (planningutils)link, (planningutils)bodyexcluded, (planningutils)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, (planningutils)bodyexcluded, (planningutils)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, (planningutils)bodyexcluded, (planningutils)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, (planningutils)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.

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)

Get all bodies loaded in the environment (including robots).

Parameters
bodies -
filled with all 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 :

uint32_t GetDebugLevel()

GetHomeDirectory((Environment)arg1) → str :

const 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 :

boost::shared_ptr< void > GetModules(std::list< ModuleBasePtr > & listModules)

Returns a list of loaded problems with a pointer to a lock preventing the list from being modified.

As long as the lock is held, the problems are guaranteed to stay loaded in the environment.

Return
returns a pointer to a Lock. Destroying the shared_ptr will release the lock
GetModules((Environment)arg1) → object :

boost::shared_ptr< void > GetModules(std::list< ModuleBasePtr > & listModules)

Returns a list of loaded problems with a pointer to a lock preventing the list from being modified.

As long as the lock is held, the problems are guaranteed to stay loaded in the environment.

Return
returns a pointer to a Lock. Destroying the shared_ptr will release the lock
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)

Fill an array with all robots loaded in the environment.
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)

Fill an array with all sensors loaded in the environment.

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.

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.

Load( (Environment)arg1, (str)filename, (dict)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.
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, (dict)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.
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, (dict)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, (dict)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, (dict)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, (dict)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, (dict)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, (dict)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, (dict)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, (dict)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, (dict)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, (dict)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, (dict)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, (dict)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, (planningutils)callback) → VoidHandle :

boost::shared_ptr< void > 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 body)

RemoveProblem((Environment)arg1, (Module)prob) → bool :

bool RemoveProblem(ModuleBasePtr prob)

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) → None :

void Save(const std::string & filename, SelectionOptions options = SO_Everything , const std::string & selectname = “” )

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
selectname -
Exceptions
openrave_exception -
Throw if failed to save anything

Save( (Environment)arg1, (str)filename, (SelectionOptions)options, (str)selectname) -> None :

void Save(const std::string & filename, SelectionOptions options = SO_Everything , const std::string & selectname = “” )

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
selectname -
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
BodyList = openravepy.openravepy_int.SelectionOptions.BodyList
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, 'BodyList': openravepy.openravepy_int.SelectionOptions.BodyList, 'Robots': openravepy.openravepy_int.SelectionOptions.Robots, 'NoRobots': openravepy.openravepy_int.SelectionOptions.NoRobots, 'Everything': openravepy.openravepy_int.SelectionOptions.Everything, '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, 6: openravepy.openravepy_int.SelectionOptions.BodyList}
Environment.SetCollisionChecker((Environment)arg1, (CollisionChecker)collisionchecker) → bool :

bool SetCollisionChecker(CollisionCheckerBasePtr pchecker)

set the global environment collision checker
Environment.SetDebugLevel((Environment)arg1, (int)level) → None :

void SetDebugLevel(uint32_t 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, (planningutils)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()

updates the published bodies that viewers and other programs listening in on the environment see. 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, (planningutils)p1, (planningutils)p2[, (float)linewidth[, (planningutils)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, (planningutils)pos, (planningutils)extents[, (planningutils)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, (planningutils)points, (float)linewidth[, (planningutils)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, (planningutils)points, (float)linewidth[, (planningutils)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, (planningutils)transform, (planningutils)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, (planningutils)transform, (planningutils)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, (planningutils)points[, (planningutils)indices[, (planningutils)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, (planningutils)points, (float)pointsize[, (planningutils)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
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, '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}
class openravepy.openravepy_int.GraphHandle

Bases: Boost.Python.instance

SetShow((GraphHandle)arg1, (bool)arg2) → None :

void SetShow(bool bshow)

Shows or hides the plot without destroying its resources.
SetTransform((GraphHandle)arg1, (planningutils)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
IgnoreJointLimits = openravepy.openravepy_int.IkFilterOptions.IgnoreJointLimits
IgnoreSelfCollisions = openravepy.openravepy_int.IkFilterOptions.IgnoreSelfCollisions
names = {'CheckEnvCollisions': openravepy.openravepy_int.IkFilterOptions.CheckEnvCollisions, 'IgnoreEndEffectorCollisions': openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorCollisions, 'IgnoreSelfCollisions': openravepy.openravepy_int.IkFilterOptions.IgnoreSelfCollisions, 'IgnoreCustomFilters': openravepy.openravepy_int.IkFilterOptions.IgnoreCustomFilters, 'IgnoreJointLimits': openravepy.openravepy_int.IkFilterOptions.IgnoreJointLimits}
values = {8: openravepy.openravepy_int.IkFilterOptions.IgnoreCustomFilters, 1: openravepy.openravepy_int.IkFilterOptions.CheckEnvCollisions, 2: openravepy.openravepy_int.IkFilterOptions.IgnoreSelfCollisions, 4: openravepy.openravepy_int.IkFilterOptions.IgnoreJointLimits, 16: openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorCollisions}
class openravepy.openravepy_int.IkFilterReturn

Bases: Boost.Python.enum

IkFilterReturn

Return value for the ik filter that can be optionally set on an ik solver.
Quit = openravepy.openravepy_int.IkFilterReturn.Quit
Reject = openravepy.openravepy_int.IkFilterReturn.Reject
Success = openravepy.openravepy_int.IkFilterReturn.Success
names = {'Quit': openravepy.openravepy_int.IkFilterReturn.Quit, 'Success': openravepy.openravepy_int.IkFilterReturn.Success, 'Reject': openravepy.openravepy_int.IkFilterReturn.Reject}
values = {0: openravepy.openravepy_int.IkFilterReturn.Success, 1: openravepy.openravepy_int.IkFilterReturn.Reject, 2: openravepy.openravepy_int.IkFilterReturn.Quit}
class openravepy.openravepy_int.IkParameterization

Bases: Boost.Python.instance

ComputeDistanceSqr((IkParameterization)arg1, (IkParameterization)arg2) → float :

dReal ComputeDistanceSqr(const IkParameterization & ikparam)

Computes the distance squared between two IK parmaeterizations.
GetConfigurationSpecification((IkParameterization)arg1) → ConfigurationSpecification :
ConfigurationSpecification GetConfigurationSpecification()

GetConfigurationSpecification( (IkParameterization)arg1, (planningutils)type) -> ConfigurationSpecification :

ConfigurationSpecification GetConfigurationSpecification()
GetConfigurationSpecificationFromType((IkParameterizationType)type) → ConfigurationSpecification :

ConfigurationSpecification GetConfigurationSpecification()

GetDOF((IkParameterization)arg1) → int :

int GetDOF()

Returns the minimum degree of freedoms required for the IK type.

GetDOF( (IkParameterization)arg1, (planningutils)type) -> int :

int GetDOF()

Returns the minimum degree of freedoms required for the IK type.
GetDOFFromType((IkParameterizationType)type) → int :

int GetDOF()

Returns the minimum degree of freedoms required for the IK type.
GetDirection((IkParameterization)arg1) → object :

const Vector & GetDirection3D()

GetDirection3D((IkParameterization)arg1) → object :

const Vector & GetDirection3D()

GetLookat((IkParameterization)arg1) → object :

const Vector & GetLookat3D()

GetLookat3D((IkParameterization)arg1) → object :

const Vector & GetLookat3D()

GetNumberOfValues((IkParameterization)arg1) → int :

int GetNumberOfValues()

Returns the number of values used to represent the parameterization ( >= dof ). The number of values serialized is this number plus 1 for the iktype.

GetNumberOfValues( (IkParameterization)arg1, (planningutils)type) -> int :

int GetNumberOfValues()

Returns the number of values used to represent the parameterization ( >= dof ). The number of values serialized is this number plus 1 for the iktype.
GetNumberOfValuesFromType((IkParameterizationType)type) → int :

int GetNumberOfValues()

Returns the number of values used to represent the parameterization ( >= dof ). The number of values serialized is this number plus 1 for the iktype.
GetRay((IkParameterization)arg1) → Ray :

const RAY GetRay4D()

GetRay4D((IkParameterization)arg1) → Ray :

const RAY GetRay4D()

GetRotation((IkParameterization)arg1) → object :

const Vector & GetRotation3D()

GetRotation3D((IkParameterization)arg1) → object :

const Vector & GetRotation3D()

GetTransform((IkParameterization)arg1) → object :

const Transform & GetTransform6D()

GetTransform6D((IkParameterization)arg1) → object :

const Transform & GetTransform6D()

GetTranslation((IkParameterization)arg1) → object :

const Vector & GetTranslation3D()

GetTranslation3D((IkParameterization)arg1) → object :

const Vector & GetTranslation3D()

GetTranslationDirection((IkParameterization)arg1) → Ray :

const RAY GetTranslationDirection5D()

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.

SetDirection((IkParameterization)arg1, (planningutils)dir) → None :

void SetDirection3D(const Vector & dir)

SetDirection3D((IkParameterization)arg1, (planningutils)dir) → None :

void SetDirection3D(const Vector & dir)

SetLookat((IkParameterization)arg1, (planningutils)pos) → None :

void SetLookat3D(const Vector & trans)

SetLookat3D((IkParameterization)arg1, (planningutils)pos) → None :

void SetLookat3D(const Vector & trans)

SetRay((IkParameterization)arg1, (Ray)quat) → None :

void SetRay4D(const RAY & ray)

SetRay4D((IkParameterization)arg1, (Ray)quat) → None :

void SetRay4D(const RAY & ray)

SetRotation((IkParameterization)arg1, (planningutils)quat) → None :

void SetRotation3D(const Vector & quaternion)

SetRotation3D((IkParameterization)arg1, (planningutils)quat) → None :

void SetRotation3D(const Vector & quaternion)

SetTransform((IkParameterization)arg1, (planningutils)transform) → None :

void SetTransform6D(const Transform & t)

SetTransform6D((IkParameterization)arg1, (planningutils)transform) → None :

void SetTransform6D(const Transform & t)

SetTranslation((IkParameterization)arg1, (planningutils)pos) → None :

void SetTranslation3D(const Vector & trans)

SetTranslation3D((IkParameterization)arg1, (planningutils)pos) → None :

void SetTranslation3D(const Vector & trans)

SetTranslationDirection((IkParameterization)arg1, (Ray)quat) → None :

void SetTranslationDirection5D(const RAY & ray)

SetTranslationDirection5D((IkParameterization)arg1, (Ray)quat) → None :

void SetTranslationDirection5D(const RAY & ray)

SetTranslationLocalGlobal6D((IkParameterization)arg1, (planningutils)localpos, (planningutils)pos) → None :

void SetTranslationLocalGlobal6D(const Vector & localtrans, const Vector & trans)

SetTranslationXAxisAngle4D((IkParameterization)arg1, (planningutils)translation, (float)angle) → None :

void SetTranslationXAxisAngle4D(const Vector & trans, dReal angle)

SetTranslationXAxisAngleZNorm4D((IkParameterization)arg1, (planningutils)translation, (float)angle) → None :

void SetTranslationXAxisAngleZNorm4D(const Vector & trans, dReal angle)

SetTranslationXY2D((IkParameterization)arg1, (planningutils)pos) → None :

void SetTranslationXY2D(const Vector & trans)

SetTranslationXYOrientation3D((IkParameterization)arg1, (planningutils)posangle) → None :

void SetTranslationXYOrientation3D(const Vector & trans)

SetTranslationYAxisAngle4D((IkParameterization)arg1, (planningutils)translation, (float)angle) → None :

void SetTranslationYAxisAngle4D(const Vector & trans, dReal angle)

SetTranslationYAxisAngleXNorm4D((IkParameterization)arg1, (planningutils)translation, (float)angle) → None :

void SetTranslationYAxisAngleXNorm4D(const Vector & trans, dReal angle)

SetTranslationZAxisAngle4D((IkParameterization)arg1, (planningutils)translation, (float)angle) → None :

void SetTranslationZAxisAngle4D(const Vector & trans, dReal angle)

SetTranslationZAxisAngleYNorm4D((IkParameterization)arg1, (planningutils)translation, (float)angle) → None :

void SetTranslationZAxisAngleYNorm4D(const Vector & trans, dReal angle)

SetValues((IkParameterization)arg1, (planningutils)values, (IkParameterizationType)type) → None
Transform((IkParameterization)arg1, (planningutils)arg2) → object :

Transforms the IK parameterization by this (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.

Direction3D = openravepy.openravepy_int.IkParameterizationType.Direction3D
Lookat3D = openravepy.openravepy_int.IkParameterizationType.Lookat3D
Ray4D = openravepy.openravepy_int.IkParameterizationType.Ray4D
Rotation3D = openravepy.openravepy_int.IkParameterizationType.Rotation3D
Transform6D = openravepy.openravepy_int.IkParameterizationType.Transform6D
Translation3D = openravepy.openravepy_int.IkParameterizationType.Translation3D
TranslationDirection5D = openravepy.openravepy_int.IkParameterizationType.TranslationDirection5D
TranslationLocalGlobal6D = openravepy.openravepy_int.IkParameterizationType.TranslationLocalGlobal6D
TranslationXAxisAngle4D = openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngle4D
TranslationXAxisAngleZNorm4D = openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngleZNorm4D
TranslationXY2D = openravepy.openravepy_int.IkParameterizationType.TranslationXY2D
TranslationXYOrientation3D = openravepy.openravepy_int.IkParameterizationType.TranslationXYOrientation3D
TranslationYAxisAngle4D = openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngle4D
TranslationYAxisAngleXNorm4D = openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngleXNorm4D
TranslationZAxisAngle4D = openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngle4D
TranslationZAxisAngleYNorm4D = openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngleYNorm4D
names = {'Transform6D': openravepy.openravepy_int.IkParameterizationType.Transform6D, 'Lookat3D': openravepy.openravepy_int.IkParameterizationType.Lookat3D, 'TranslationXY2D': openravepy.openravepy_int.IkParameterizationType.TranslationXY2D, 'TranslationXAxisAngle4D': openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngle4D, 'Ray4D': openravepy.openravepy_int.IkParameterizationType.Ray4D, 'TranslationZAxisAngle4D': openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngle4D, 'Translation3D': openravepy.openravepy_int.IkParameterizationType.Translation3D, 'TranslationXAxisAngleZNorm4D': openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngleZNorm4D, 'TranslationXYOrientation3D': openravepy.openravepy_int.IkParameterizationType.TranslationXYOrientation3D, 'TranslationYAxisAngle4D': openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngle4D, 'TranslationYAxisAngleXNorm4D': openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngleXNorm4D, 'TranslationDirection5D': openravepy.openravepy_int.IkParameterizationType.TranslationDirection5D, 'Direction3D': openravepy.openravepy_int.IkParameterizationType.Direction3D, 'TranslationZAxisAngleYNorm4D': openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngleYNorm4D, 'TranslationLocalGlobal6D': openravepy.openravepy_int.IkParameterizationType.TranslationLocalGlobal6D, 'Rotation3D': openravepy.openravepy_int.IkParameterizationType.Rotation3D}
values = {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}
class openravepy.openravepy_int.IkSolver

Bases: openravepy.openravepy_int.Interface

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, (planningutils)callback) → object :

UserDataPtr RegisterCustomFilter(int priority, const IkFilterCallbackFn & filterfn)

Sets an ik solution filter that is called for every ik solution.

Parameters
filterfn -
  • an optional filter function to be called, see IkFilterCallbackFn.
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. 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 .
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

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) → str :

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
GetUserData((Interface)arg1) → 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
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)

SetUserData((Interface)arg1, (UserData)data) → None :

void SetUserData(UserDataPtr data)

set user data

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

void SetUserData(UserDataPtr data)

set user data
class openravepy.openravepy_int.InterfaceBase

Bases: Boost.Python.instance

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

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, boost::multi_array< dReal , 2 > & vjacobian)

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.CalculateJacobian((KinBody)arg1, (int)linkindex, (planningutils)offset) → object :

void CalculateJacobian(int linkindex, const Vector & offset, boost::multi_array< dReal , 2 > & vjacobian)

Computes the translation jacobian with respect to a world position.

Parameters
linkindex -
of the link that the rotation is attached to
position -
position in world space where to compute derivatives from.
vjacobian -
3xDOF matrix 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.CalculateRotationJacobian((KinBody)arg1, (int)linkindex, (planningutils)quat) → object :

void CalculateRotationJacobian(int linkindex, const Vector & quat, boost::multi_array< dReal , 2 > & vjacobian)

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.
vjacobian -
4xDOF matrix
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.CreateKinBodyStateSaver((KinBody)arg1) → VoidHandle :
Creates KinBodySaveStater for this body
CreateKinBodyStateSaver( (KinBody)arg1, (int)options) -> VoidHandle :
Creates KinBodySaveStater for this body
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.

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)

Computes the minimal chain of joints that are between two links in the order of linkindex1 to linkindex2.

Parameters
linkindex1 -
the link index to start the search
linkindex2 -
the link index where the search ends
vjoints -
the joints to fill that describe the chain Passive joints are also used in the computation of the chain and can be returned. Note that a passive joint has a joint index and dof index of -1.
Return
true if the two links are connected (vjoints will be filled), false if the links are separate 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) → object :

const ConfigurationSpecification & GetConfigurationSpecification()

return the configuration specification of the joint values and transform
KinBody.GetConfigurationSpecificationIndices((KinBody)arg1, (planningutils)indices) → object :

ConfigurationSpecification GetConfigurationSpecificationIndices(const std::vector< int > & indices)

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)

Returns the max acceleration for each DOF.

GetDOFAccelerationLimits( (KinBody)arg1, (planningutils)indices) -> object :

void GetDOFAccelerationLimits(std::vector< dReal > & maxaccelerations)

Returns the max acceleration for each DOF.
KinBody.GetDOFLimits((KinBody)arg1) → object :

void GetDOFLimits(std::vector< dReal > & lowerlimit, std::vector< dReal > & upperlimit)

Returns all the joint limits as organized by the DOF indices.

GetDOFLimits( (KinBody)arg1, (planningutils)indices) -> object :

void GetDOFLimits(std::vector< dReal > & lowerlimit, std::vector< dReal > & upperlimit)

Returns all the joint limits as organized by the DOF indices.
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)

GetDOFResolutions( (KinBody)arg1, (planningutils)arg2) -> object :

void GetDOFResolutions(std::vector< dReal > & v)
KinBody.GetDOFTorqueLimits((KinBody)arg1) → object :

void GetDOFTorqueLimits(std::vector< dReal > & maxaccelerations)

Returns the max torque for each DOF.

GetDOFTorqueLimits( (KinBody)arg1, (planningutils)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)

Returns all the joint values as organized by the DOF indices.

GetDOFValues( (KinBody)arg1, (planningutils)indices) -> object :

void GetDOFValues(std::vector< dReal > & v)

Returns all the joint values as organized by the DOF indices.
KinBody.GetDOFVelocities((KinBody)arg1) → object :

void GetDOFVelocities(std::vector< dReal > & v)

Returns all the joint velocities as organized by the DOF indices.
KinBody.GetDOFVelocityLimits((KinBody)arg1) → object :

void GetDOFVelocityLimits(std::vector< dReal > & lowerlimit, std::vector< dReal > & upperlimit)

Returns all the joint velocity limits as organized by the DOF indices.

GetDOFVelocityLimits( (KinBody)arg1, (planningutils)indices) -> object :

void GetDOFVelocityLimits(std::vector< dReal > & lowerlimit, std::vector< dReal > & upperlimit)

Returns all the joint velocity limits as organized by the DOF indices.
KinBody.GetDOFWeights((KinBody)arg1) → object :
void GetDOFWeights(std::vector< dReal > & v)

GetDOFWeights( (KinBody)arg1, (planningutils)arg2) -> object :

void GetDOFWeights(std::vector< dReal > & v)
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) → Joint :

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) → Joint :

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, (planningutils)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.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.

const std::vector< LinkPtr > & GetLinks()

Returns all the rigid links of the body.

GetLinks( (KinBody)arg1, (planningutils)indices) -> object :

const std::vector< LinkPtr > & GetLinks()

Returns all the rigid links of the body.
KinBody.GetManageData((KinBody)arg1) → ManageData :

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(int linkindex, std::vector< LinkPtr > & vattachedlinks)

See
Link::GetRigidlyAttachedLinks (10/12/12)
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.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.InitFromData((KinBody)arg1, (str)data) → bool :

bool InitFromData(const std::string & data, const AttributesList & atts = AttributesList () )

See
EnvironmentBase::ReadKinBodyXMLData
KinBody.InitFromFile((KinBody)arg1, (str)filename) → bool :

bool InitFromFile(const std::string & filename, const AttributesList & atts = AttributesList () )

See
EnvironmentBase::ReadKinBodyXMLFile
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, (planningutils)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

AddTorque((Joint)arg1, (planningutils)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()

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

Returns 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()

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) → Type :

JointType GetType()

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
GetWeights((Joint)arg1) → object :

dReal GetWeight(int axis = 0 )

The weight associated with a joint’s axis for computing a distance in the robot configuration space.
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, (planningutils)maxlimits) → None :

void SetAccelerationLimits(const std::vector< dReal > & vmax)

See
GetAccelerationLimits
SetLimits((Joint)arg1, (planningutils)lower, (planningutils)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)

SetTorqueLimits((Joint)arg1, (planningutils)maxlimits) → None :

void SetTorqueLimits(const std::vector< dReal > & vmax)

See
GetTorqueLimits
SetVelocityLimits((Joint)arg1, (planningutils)maxlimits) → None :

void SetVelocityLimits(const std::vector< dReal > & vmax)

See
GetVelocityLimits
SetWeights((Joint)arg1, (planningutils)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
SubtractValues((Joint)arg1, (planningutils)values0, (planningutils)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.

class Type

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.Type.Hinge
Hinge2 = openravepy.openravepy_int.Type.Hinge2
None = openravepy.openravepy_int.Type.None
PP = openravepy.openravepy_int.Type.PP
PR = openravepy.openravepy_int.Type.PR
Prismatic = openravepy.openravepy_int.Type.Prismatic
RP = openravepy.openravepy_int.Type.RP
RR = openravepy.openravepy_int.Type.RR
Revolute = openravepy.openravepy_int.Type.Revolute
Slider = openravepy.openravepy_int.Type.Slider
Spherical = openravepy.openravepy_int.Type.Spherical
Universal = openravepy.openravepy_int.Type.Universal
names = {'PR': openravepy.openravepy_int.Type.PR, 'Spherical': openravepy.openravepy_int.Type.Spherical, 'None': openravepy.openravepy_int.Type.None, 'RP': openravepy.openravepy_int.Type.RP, 'RR': openravepy.openravepy_int.Type.RR, 'Prismatic': openravepy.openravepy_int.Type.Prismatic, 'Universal': openravepy.openravepy_int.Type.Universal, 'Hinge2': openravepy.openravepy_int.Type.Hinge2, 'PP': openravepy.openravepy_int.Type.PP, 'Hinge': openravepy.openravepy_int.Type.Hinge, 'Slider': openravepy.openravepy_int.Type.Slider, 'Revolute': openravepy.openravepy_int.Type.Revolute}
values = {0: openravepy.openravepy_int.Type.None, 1: openravepy.openravepy_int.Type.Revolute, 2: openravepy.openravepy_int.Type.RR, 50: openravepy.openravepy_int.Type.PP, 2147483649: openravepy.openravepy_int.Type.Universal, 2147483650: openravepy.openravepy_int.Type.Hinge2, 34: openravepy.openravepy_int.Type.PR, 17: openravepy.openravepy_int.Type.Prismatic, 18: openravepy.openravepy_int.Type.RP, 2147483651: openravepy.openravepy_int.Type.Spherical}

Bases: Boost.Python.instance

ComputeAABB((Link)arg1) → object :

AABB ComputeAABB()

Compute the aabb of all the geometries of the link in the world coordinate system.
Enable((Link)arg1, (bool)enable) → None :

void Enable(bool enable)

Enables a Link. An enabled link takes part in collision detection and physics simulations.
class GeomProperties

Bases: Boost.Python.instance

GetBoxExtents((GeomProperties)arg1) → object :

const Vector & GetBoxExtents()

GetCollisionMesh((GeomProperties)arg1) → object :

const TRIMESH & GetCollisionMesh()

collision data of the specific object in its local coordinate system.

Should be transformed by GEOMPROPERTIES::GetTransform() before rendering. For spheres and cylinders, an appropriate discretization value is chosen.

GetCylinderHeight((GeomProperties)arg1) → float :

dReal GetCylinderHeight()

GetCylinderRadius((GeomProperties)arg1) → float :

dReal GetCylinderRadius()

GetRenderFilename((GeomProperties)arg1) → object :

const std::string & GetRenderFilename()

render resource file, should be transformed by _t before rendering

If the value is “__norenderif__:x”, then the viewer should not render the object if it supports *.x files where”x” is the file extension.

GetRenderScale((GeomProperties)arg1) → object :

const Vector & GetRenderScale()

GetSphereRadius((GeomProperties)arg1) → float :

dReal GetSphereRadius()

GetTransform((GeomProperties)arg1) → object :

const Transform & GetTransform()

Local transformation of the geom primitive with respect to the link’s coordinate system.
GetTransparency((GeomProperties)arg1) → float :

float GetTransparency()

GetType((GeomProperties)arg1) → Type :

GeomType GetType()

IsDraw((GeomProperties)arg1) → bool :

bool IsDraw()

IsModifiable((GeomProperties)arg1) → bool :

bool IsModifiable()

SetAmbientColor((GeomProperties)arg1, (planningutils)color) → None :

void SetAmbientColor(const RaveVector< float > & color)

override ambient color of geometry material
SetCollisionMesh((GeomProperties)arg1, (planningutils)trimesh) → None :

void SetCollisionMesh(const TRIMESH & mesh)

sets a new collision mesh and notifies every registered callback about it
SetDiffuseColor((GeomProperties)arg1, (planningutils)color) → None :

void SetDiffuseColor(const RaveVector< float > & color)

override diffuse color of geometry material
SetDraw((GeomProperties)arg1, (bool)draw) → None :

void SetDraw(bool bDraw)

SetRenderFilename((GeomProperties)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((GeomProperties)arg1, (float)transparency) → None :

void SetTransparency(float f)

set transparency level (0 is opaque)
class Type

Bases: Boost.Python.enum

GeomType

The type of geometry primitive.
Box = openravepy.openravepy_int.Type.Box
Cylinder = openravepy.openravepy_int.Type.Cylinder
None = openravepy.openravepy_int.Type.None
Sphere = openravepy.openravepy_int.Type.Sphere
Trimesh = openravepy.openravepy_int.Type.Trimesh
names = {'Box': openravepy.openravepy_int.Type.Box, 'Sphere': openravepy.openravepy_int.Type.Sphere, 'None': openravepy.openravepy_int.Type.None, 'Cylinder': openravepy.openravepy_int.Type.Cylinder, 'Trimesh': openravepy.openravepy_int.Type.Trimesh}
values = {0: openravepy.openravepy_int.Type.None, 1: openravepy.openravepy_int.Type.Box, 2: openravepy.openravepy_int.Type.Sphere, 3: openravepy.openravepy_int.Type.Cylinder, 4: openravepy.openravepy_int.Type.Trimesh}
KinBody.Link.GetCOMOffset((Link)arg1) → object :

Vector GetCOMOffset()

KinBody.Link.GetCollisionData((Link)arg1) → object :

const TRIMESH & GetCollisionData()

KinBody.Link.GetGeometries((Link)arg1) → object :

const std::list< GEOMPROPERTIES > & 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.GetIndex((Link)arg1) → int :

int GetIndex()

unique index into parent KinBody::GetLinks vector
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 COM is GetLocalCOM()
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)

Parameters
linearvel -
the translational velocity
angularvel -
is the rotation axis * angular speed get the velocity of the link
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.SetForce((Link)arg1, (planningutils)force, (planningutils)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.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, (planningutils)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, (planningutils)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, (planningutils)arg2, (planningutils)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
class KinBody.ManageData

Bases: Boost.Python.instance

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
LinkEnable = openravepy.openravepy_int.SaveParameters.LinkEnable
LinkTransformation = openravepy.openravepy_int.SaveParameters.LinkTransformation
names = {'ActiveDOF': openravepy.openravepy_int.SaveParameters.ActiveDOF, 'LinkTransformation': openravepy.openravepy_int.SaveParameters.LinkTransformation, 'GrabbedBodies': openravepy.openravepy_int.SaveParameters.GrabbedBodies, 'ActiveManipulator': openravepy.openravepy_int.SaveParameters.ActiveManipulator, 'LinkEnable': openravepy.openravepy_int.SaveParameters.LinkEnable}
values = {65536: openravepy.openravepy_int.SaveParameters.ActiveDOF, 1: openravepy.openravepy_int.SaveParameters.LinkTransformation, 2: openravepy.openravepy_int.SaveParameters.LinkEnable, 131072: openravepy.openravepy_int.SaveParameters.ActiveManipulator, 262144: openravepy.openravepy_int.SaveParameters.GrabbedBodies}
KinBody.SetBodyTransformations((KinBody)arg1, (planningutils)arg2, (planningutils)transforms) → None :

void SetLinkTransformations(const std::vector< Transform > & transforms)

sets the transformations of all the links at once
KinBody.SetConfigurationValues((KinBody)arg1, (planningutils)values, (bool)checklimits) → None :

void SetConfigurationValues(std::vector< dReal >::const_iterator itvalues, bool checklimits = true )

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!
KinBody.SetDOFAccelerationLimits((KinBody)arg1, (planningutils)limits) → None :

void SetDOFAccelerationLimits(const std::vector< dReal > & maxlimits)

See
GetDOFAccelerationLimits
KinBody.SetDOFTorqueLimits((KinBody)arg1, (planningutils)limits) → None :

void SetDOFTorqueLimits(const std::vector< dReal > & maxlimits)

See
GetDOFTorqueLimits
KinBody.SetDOFTorques((KinBody)arg1, (planningutils)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, (planningutils)values) → None :

void SetDOFValues(const std::vector< dReal > & values, bool checklimits = true )

Sets the joint values of the robot.

Parameters
values -
the values to set the joint angles (ordered by the dof indices) checklimits if true, will excplicitly check the joint limits before setting the values.

SetDOFValues( (KinBody)arg1, (planningutils)values, (planningutils)dofindices) -> None :

void SetDOFValues(const std::vector< dReal > & values, bool checklimits = true )

Sets the joint values of the robot.

Parameters
values -
the values to set the joint angles (ordered by the dof indices) checklimits if true, will excplicitly check the joint limits before setting the values.

SetDOFValues( (KinBody)arg1, (planningutils)values, (planningutils)dofindices, (bool)checklimits) -> None :

void SetDOFValues(const std::vector< dReal > & values, bool checklimits = true )

Sets the joint values of the robot.

Parameters
values -
the values to set the joint angles (ordered by the dof indices) checklimits if true, will excplicitly check the joint limits before setting the values.
KinBody.SetDOFVelocities((KinBody)arg1, (planningutils)dofvelocities) → None :

void SetDOFVelocities(const std::vector< dReal > & vDOFVelocities, bool checklimits = true )

Sets the velocity of the joints.

Parameters
vDOFVelocity -
  • velocities of each of the degrees of freeom checklimits if true, will excplicitly check the joint velocity limits before setting the values. Copies the current velocity of the base link and calls SetDOFVelocities(linearvel,angularvel,vDOFVelocities)

SetDOFVelocities( (KinBody)arg1, (planningutils)dofvelocities, (planningutils)linear, (planningutils)angular) -> None :

void SetDOFVelocities(const std::vector< dReal > & vDOFVelocities, const Vector & linearvel, const Vector & angularvel, bool checklimits = true )

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
vDOFVelocities -
  • velocities of each of the degrees of freeom
checklimits -
if true, will excplicitly check the joint velocity limits before setting the values. 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, (planningutils)dofvelocities, (bool)checklimits) -> None :

void SetDOFVelocities(const std::vector< dReal > & vDOFVelocities, bool checklimits = true )

Sets the velocity of the joints.

Parameters
vDOFVelocity -
  • velocities of each of the degrees of freeom checklimits if true, will excplicitly check the joint velocity limits before setting the values. Copies the current velocity of the base link and calls SetDOFVelocities(linearvel,angularvel,vDOFVelocities)

SetDOFVelocities( (KinBody)arg1, (planningutils)dofvelocities, (planningutils)linear, (planningutils)angular, (bool)checklimits) -> None :

void SetDOFVelocities(const std::vector< dReal > & vDOFVelocities, const Vector & linearvel, const Vector & angularvel, bool checklimits = true )

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
vDOFVelocities -
  • velocities of each of the degrees of freeom
checklimits -
if true, will excplicitly check the joint velocity limits before setting the values. 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, (planningutils)limits) → None :

void SetDOFVelocityLimits(const std::vector< dReal > & maxlimits)

See
GetDOFVelocityLimits
KinBody.SetDOFWeights((KinBody)arg1, (planningutils)weights) → None :

void SetDOFWeights(const std::vector< dReal > & weights)

See
GetDOFWeights
KinBody.SetJointTorques((KinBody)arg1, (planningutils)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, (planningutils)values) → None :

void SetDOFValues(const std::vector< dReal > & values, bool checklimits = true )

Sets the joint values of the robot.

Parameters
values -
the values to set the joint angles (ordered by the dof indices) checklimits if true, will excplicitly check the joint limits before setting the values.

SetJointValues( (KinBody)arg1, (planningutils)values, (planningutils)dofindices) -> None :

void SetDOFValues(const std::vector< dReal > & values, bool checklimits = true )

Sets the joint values of the robot.

Parameters
values -
the values to set the joint angles (ordered by the dof indices) checklimits if true, will excplicitly check the joint limits before setting the values.
KinBody.SetLinkTransformations((KinBody)arg1, (planningutils)transforms[, (planningutils)dofbranches]) → None :

void SetLinkTransformations(const std::vector< Transform > & transforms)

sets the transformations of all the links at once
KinBody.SetLinkVelocities((KinBody)arg1, (planningutils)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.SetTransform((KinBody)arg1, (planningutils)transform) → None :

void SetTransform(const Transform & transform)

set the transform of the first link (the rest of the links are computed based on the joint values).

Parameters
transform -
affine transformation
KinBody.SetTransformWithDOFValues((KinBody)arg1, (planningutils)transform, (planningutils)values) → None :

void SetDOFValues(const std::vector< dReal > & values, const Transform & transform, bool checklimits = true )

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 if true, will excplicitly check the joint limits before setting the values.
KinBody.SetTransformWithJointValues((KinBody)arg1, (planningutils)transform, (planningutils)values) → None :

void SetDOFValues(const std::vector< dReal > & values, const Transform & transform, bool checklimits = true )

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 if true, will excplicitly check the joint limits before setting the values.
KinBody.SetVelocity((KinBody)arg1, (planningutils)linear, (planningutils)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, (planningutils)values0, (planningutils)values1) → object :

void SubtractDOFValues(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.

KinBody.serialize((KinBody)arg1, (int)options) → str :

void serialize(std::ostream & o, int options)

class openravepy.openravepy_int.Module

Bases: openravepy.openravepy_int.Interface

SimulationStep((Module)arg1, (float)arg2) → bool
class openravepy.openravepy_int.PhysicsEngine

Bases: openravepy.openravepy_int.Interface

AddJointTorque((PhysicsEngine)arg1, (planningutils)arg2, (planningutils)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, (planningutils)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, (planningutils)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, (planningutils)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, (planningutils)arg2, (planningutils)arg3, (planningutils)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, (planningutils)arg2, (planningutils)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, (planningutils)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, (planningutils)arg2, (planningutils)body, (planningutils)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, (planningutils)arg2, (planningutils)link, (planningutils)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

GetParameters((Planner)arg1) → PlannerParameters :

PlannerParametersConstPtr GetParameters()

return the internal parameters of the planner
InitPlan((Planner)arg1, (Robot)robot, (PlannerParameters)params) → 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 :

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

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

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

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.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.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[, (int)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 and logging. Although environment creation will automatically make sure this function is called, users might want explicit control of when this happens.
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.RaveSetDebugLevel((int)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

dir((Ray)arg1) → object
pos((Ray)arg1) → object
class openravepy.openravepy_int.Robot

Bases: openravepy.openravepy_int.KinBody, openravepy.openravepy_int.Interface

class AttachedSensor

Bases: Boost.Python.instance

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, (planningutils)transform) → None :

void SetRelativeTransform(const Transform & t)

Robot.CalculateActiveAngularVelocityJacobian((Robot)arg1, (int)linkindex) → object :

void CalculateActiveAngularVelocityJacobian(int index, boost::multi_array< dReal , 2 > & mjacobian)

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, (planningutils)offset) → object :

void CalculateActiveJacobian(int index, const Vector & offset, boost::multi_array< dReal , 2 > & mjacobian)

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, (planningutils)quat) → object :

void CalculateActiveRotationJacobian(int index, const Vector & qInitialRot, boost::multi_array< dReal , 2 > & vjacobian)

Robot.CreateRobotStateSaver((Robot)arg1) → VoidHandle :
Creates RobotSaveStater for this robot.
CreateRobotStateSaver( (Robot)arg1, (int)options) -> VoidHandle :
Creates RobotSaveStater for this robot.
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
RotationQuat = openravepy.openravepy_int.DOFAffine.RotationQuat
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, '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, 16: openravepy.openravepy_int.DOFAffine.Rotation3D}
Robot.GetActiveConfigurationSpecification((Robot)arg1) → object :

const ConfigurationSpecification & GetActiveConfigurationSpecification()

return the configuration specification of the active dofs
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()

Return
index of the current active manipulator
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.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, (planningutils)linkstoignre) -> bool :

bool Grab(KinBodyPtr body, const std::set< int > & setRobotLinksToIgnore)

Grabs the body with the active manipulator’s end effector.

Parameters
body -
the body to be grabbed
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

Grab( (Robot)arg1, (KinBody)body, (Link)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, (Link)grablink, (planningutils)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.Grabbed

Bases: Boost.Python.instance

grabbedbody
linkrobot
troot
Robot.IsGrabbing((Robot)arg1, (KinBody)body) → Link :

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

CalculateAngularVelocityJacobian((Manipulator)arg1) → object :

void CalculateAngularVelocityJacobian(boost::multi_array< dReal , 2 > & mjacobian)

computes the angule axis jacobian of the manipulator arm indices.
CalculateJacobian((Manipulator)arg1) → object :

void CalculateJacobian(boost::multi_array< dReal , 2 > & mjacobian)

computes the jacobian of the manipulator arm indices from the current manipulator frame origin.
CalculateRotationJacobian((Manipulator)arg1) → object :

void CalculateRotationJacobian(boost::multi_array< dReal , 2 > & mjacobian)

computes the quaternion jacobian of the manipulator arm indices from the current manipulator frame rotation.
CheckEndEffectorCollision((Manipulator)arg1, (planningutils)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, (planningutils)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, (planningutils)param, (int)filteroptions) → 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, (planningutils)param, (planningutils)freevalues, (int)filteroptions) -> object :

bool FindIKSolution(const IkParameterization & param, const std::vector< dReal > & vFreeParameters, std::vector< dReal > & solution, int filteroptions)
FindIKSolutions((Manipulator)arg1, (planningutils)param, (int)filteroptions) → 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, (planningutils)param, (planningutils)freevalues, (int)filteroptions) -> object :

bool FindIKSolutions(const IkParameterization & param, const std::vector< dReal > & vFreeParameters, std::vector< std::vector< dReal > > & solutions, int filteroptions)
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) → Link :

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) → Link :

LinkPtr GetEndEffector()

the end effector link (used to define workspace distance)
GetEndEffectorTransform((Manipulator)arg1) → object :

Transform GetTransform()

Return the transformation of the end effector (manipulator frame).

All inverse kinematics and grasping queries are specifying this frame.

GetFreeParameters((Manipulator)arg1) → object :

bool GetFreeParameters(std::vector< dReal > & vFreeParameters)

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, (IkParameterizationType)iktype) → object :

IkParameterization GetIkParameterization(IkParameterizationType iktype)

returns the parameterization of a given IK type for the current manipulator position.

Parameters
iktype -
the type of parameterization to request 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.

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

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 end effector (manipulator frame).

All inverse kinematics and grasping queries are specifying this frame.

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 (_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 (_tLocalTool) internally. The actual ik primitives are transformed into the base frame only.

SetLocalToolTransform((Manipulator)arg1, (planningutils)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
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.SetActiveDOFValues((Robot)arg1, (planningutils)values) → None :

void SetActiveDOFValues(const std::vector< dReal > & values, bool checklimits = true )

Robot.SetActiveDOFVelocities((Robot)arg1, (planningutils)arg2) → None :

void SetActiveDOFVelocities(const std::vector< dReal > & velocities, bool checklimits = true )

Robot.SetActiveDOFs((Robot)arg1, (planningutils)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, (planningutils)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, (planningutils)dofindices, (int)affine, (planningutils)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)

Parameters
index -
manipulator index sets the active manipulator of the robot

SetActiveManipulator( (Robot)arg1, (str)manipname) -> Manipulator :

void SetActiveManipulator(const std::string & manipname)

Parameters
manipname -
manipulator name sets the active manipulator of the robot
SetActiveManipulator( (Robot)arg1, (Manipulator)manip) -> Manipulator :
Set the active manipulator given a pointer
Robot.SetAffineRotation3DLimits((Robot)arg1, (planningutils)lower, (planningutils)upper) → None :

void SetAffineRotation3DLimits(const Vector & lower, const Vector & upper)

Robot.SetAffineRotation3DMaxVels((Robot)arg1, (planningutils)velocity) → None :

void SetAffineRotation3DMaxVels(const Vector & vels)

Robot.SetAffineRotation3DResolution((Robot)arg1, (planningutils)resolution) → None :

void SetAffineRotation3DResolution(const Vector & resolution)

Robot.SetAffineRotation3DWeights((Robot)arg1, (planningutils)weights) → None :

void SetAffineRotation3DWeights(const Vector & weights)

Robot.SetAffineRotationAxisLimits((Robot)arg1, (planningutils)lower, (planningutils)upper) → None :

void SetAffineRotationAxisLimits(const Vector & lower, const Vector & upper)

Robot.SetAffineRotationAxisMaxVels((Robot)arg1, (planningutils)velocity) → None :

void SetAffineRotationAxisMaxVels(const Vector & vels)

Robot.SetAffineRotationAxisResolution((Robot)arg1, (planningutils)resolution) → None :

void SetAffineRotationAxisResolution(const Vector & resolution)

Robot.SetAffineRotationAxisWeights((Robot)arg1, (planningutils)weights) → None :

void SetAffineRotationAxisWeights(const Vector & weights)

Robot.SetAffineRotationQuatLimits((Robot)arg1, (planningutils)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, (planningutils)lower, (planningutils)upper) → None :

void SetAffineTranslationLimits(const Vector & lower, const Vector & upper)

Robot.SetAffineTranslationMaxVels((Robot)lower, (planningutils)upper) → None :

void SetAffineTranslationMaxVels(const Vector & vels)

Robot.SetAffineTranslationResolution((Robot)arg1, (planningutils)resolution) → None :

void SetAffineTranslationResolution(const Vector & resolution)

Robot.SetAffineTranslationWeights((Robot)arg1, (planningutils)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, (planningutils)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, (planningutils)values0, (planningutils)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

class ActuatorSensorData

Bases: openravepy.openravepy_int.SensorData

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

K
distortion_coeffs
distortion_model
focal_length
class Sensor.CameraSensorData

Bases: openravepy.openravepy_int.SensorData

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

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

angular_velocity
angular_velocity_covariance
linear_acceleration
linear_acceleration_covariance
rotation
rotation_covariance
class Sensor.JointEncoderSensorData

Bases: openravepy.openravepy_int.SensorData

encoderValues
encoderVelocity
resolution
class Sensor.LaserSensorData

Bases: openravepy.openravepy_int.SensorData

intensity
positions
ranges
class Sensor.OdometrySensorData

Bases: openravepy.openravepy_int.SensorData

angular_velocity
linear_velocity
pose
pose_covariance
targetid
velocity_covariance
class Sensor.SensorData

Bases: Boost.Python.instance

stamp
type
Sensor.SetTransform((Sensor)arg1, (planningutils)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

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

class openravepy.openravepy_int.SerializableData

Bases: openravepy.openravepy_int.UserData

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

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

Bases: openravepy.openravepy_int.Interface

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, (planningutils)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, (planningutils)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, (planningutils)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, (planningutils)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, (planningutils)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, (int)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, (int)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

indices
vertices
class openravepy.openravepy_int.UserData

Bases: Boost.Python.instance

close((UserData)arg1) → None :

force releasing the user handle point.

class openravepy.openravepy_int.Viewer

Bases: openravepy.openravepy_int.Interface

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, (planningutils)transform, (planningutils)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, (planningutils)arg2, (planningutils)callback) → VoidHandle :

boost::shared_ptr< void > 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, (planningutils)callback) → VoidHandle :

boost::shared_ptr< void > 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, (planningutils)arg2) → None :

void SetBkgndColor(const RaveVector< float > & color)

SetCamera((Viewer)arg1, (planningutils)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, (planningutils)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)arg2) → 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

close((VoidHandle)arg1) → None
class openravepy.openravepy_int.VoidPointer

Bases: Boost.Python.instance

Holds auto-managed resources, deleting it releases its shared data.

openravepy.openravepy_int.axisAngleFromQuat((planningutils)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((planningutils)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((planningutils)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((planningutils)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( (planningutils)axis, (float)angle) -> object

openravepy.openravepy_int.matrixFromPose((planningutils)pose) → object :

Converts a 7 element quaterion+translation transform to a 4x4 matrix.

Parameters:pose – 7 values
openravepy.openravepy_int.matrixFromPoses((planningutils)poses) → object :

Converts a Nx7 element quaterion+translation array to a 4x4 matrices.

Parameters:poses – nx7 array
openravepy.openravepy_int.matrixFromQuat((planningutils)quat) → object :

Converts a quaternion to a 4x4 affine matrix.

Parameters:quat – 4 values
openravepy.openravepy_int.matrixSerialization((planningutils)transform) → str :

Serializes a transformation into a string representing a 3x4 matrix.

Parameters:transform – 3x4 or 4x4 array
openravepy.openravepy_int.normalizeAxisRotation((planningutils)axis, (planningutils)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

ReturnTransformQuaternions
class openravepy.openravepy_int.planningutils

Bases: Boost.Python.instance

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 DHParameter

Bases: Boost.Python.instance

a
alpha
d
joint
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.
class planningutils.ManipulatorIKGoalSampler

Bases: Boost.Python.instance

Sample((ManipulatorIKGoalSampler)arg1) → object
planningutils.MergeTrajectories((planningutils)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[, (str)plannername[, (str)plannerparameters]]]]) → None :

OPENRAVE_API void RetimeActiveDOFTrajectory(TrajectoryBasePtr traj, RobotBasePtr robot, bool hastimestamps = false , dReal fmaxvelmult = 1 , const std::string & plannername = “” , const std::string & plannerparameters = “” )

Retime the trajectory points consisting of active dofs.

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.
planningutils.RetimeAffineTrajectory((Trajectory)trajectory, (planningutils)maxvelocities, (planningutils)maxaccelerations[, (bool)hastimestamps[, (str)plannername[, (str)plannerparameters]]]) → None :

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 dofs 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.
planningutils.ReverseTrajectory((Trajectory)trajectory) → object :

OPENRAVE_API TrajectoryBasePtr ReverseTrajectory(TrajectoryBaseConstPtr traj)

reverses the order of the trajectory waypoints and times.

Velocities are just negated and the new trajectory is not guaranteed to be executable or valid

planningutils.SmoothActiveDOFTrajectory((Trajectory)trajectory, (Robot)robot[, (bool)hastimestamps[, (float)maxvelmult[, (str)plannername[, (str)plannerparameters]]]]) → None :

OPENRAVE_API void SmoothActiveDOFTrajectory(TrajectoryBasePtr traj, RobotBasePtr robot, bool hastimestamps = false , dReal fmaxvelmult = 1 , const std::string & plannername = “” , const std::string & plannerparameters = “” )

Smooth the trajectory points consisting of active dofs of the robot while avoiding collisions.

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.
planningutils.SmoothAffineTrajectory((Trajectory)trajectory, (planningutils)maxvelocities, (planningutils)maxaccelerations[, (bool)hastimestamps[, (str)plannername[, (str)plannerparameters]]]) → None :

OPENRAVE_API void SmoothAffineTrajectory(TrajectoryBasePtr traj, const std::vector< dReal > & maxvelocities, const std::vector< dReal > & maxaccelerations, bool hastimestamps = false , const std::string & plannername = “” , const std::string & plannerparameters = “” )

Smooth the trajectory points consisting of affine dofs 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.VerifyTrajectory((planningutils)parameters, (Trajectory)trajectory, (float)samplingstep) → None :

OPENRAVE_API void VerifyTrajectory(PlannerBase::PlannerParametersConstPtr parameters, TrajectoryBaseConstPtr trajectory, dReal samplingstep = 0.002 )

validates a trajectory with respect to the planning constraints.

Parameters
trajectory -
trajectory of points to be checked
parameters -
the planner parameters passed to the planner that returned the trajectory
samplingstep -
If == 0, then will only test the supports points in trajectory->GetPoints(). If > 0, then will sample the trajectory at this time interval and check that smoothness is satisfied along with segment constraints. Exceptions
openrave_exception -
If the trajectory is invalid, will throw ORE_InconsistentConstraints. checks internal data structures and verifies that all trajectory via points do not violate joint position, velocity, and acceleration limits.
openravepy.openravepy_int.poseFromMatrices((planningutils)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((planningutils)transform) → object :

Converts a 4x4 matrix to a 7 element quaternion+translation representation.

Parameters:transform – 3x4 or 4x4 affine matrix
openravepy.openravepy_int.poseMult((planningutils)pose1, (planningutils)pose2) → object :

multiplies two poses.

Parameters:
  • pose1 – 7 values
  • pose2 – 7 values
openravepy.openravepy_int.poseSerialization((planningutils)pose) → str :

Serializes a transformation into a string representing a quaternion with translation.

Parameters:pose – 7 values
openravepy.openravepy_int.poseTransformPoints((planningutils)pose, (planningutils)points) → object :

left-transforms a set of points by a pose transformation.

Parameters:
  • pose – 7 values
  • points – Nx3 values
openravepy.openravepy_int.quatFromAxisAngle((planningutils)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( (planningutils)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((planningutils)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((planningutils)quat) → object :

RaveVector < T > quatInverse(const RaveVector < T > & quat)

Inverted a quaternion rotation.

Parameters
quat -
quaternion, (s,vx,vy,vz)
openravepy.openravepy_int.quatMult((planningutils)quat0, (planningutils)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((planningutils)quat0, (planningutils)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((planningutils)arg1, (planningutils)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((planningutils)quat0, (planningutils)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((int)level) → None :

OPENRAVE_API void RaveSetDebugLevel(int level)

Sets the global openrave debug level. A combination of DebugLevel.
openravepy.openravepy_int.rotationMatrixFromAxisAngle((planningutils)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( (planningutils)axis, (float)angle) -> object

openravepy.openravepy_int.rotationMatrixFromQArray((planningutils)quatarray) → object :

Converts an array of quaternions to a list of 3x3 rotation matrices.

Parameters:quatarray – nx4 array
openravepy.openravepy_int.rotationMatrixFromQuat((planningutils)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((planningutils)lookat, (planningutils)camerapos, (planningutils)cameraup) → object :

Returns a camera matrix that looks along a ray with a desired up vector.

Parameters:
  • lookat – unit axis, 3 values
  • camerapos – 3 values
  • cameraup – unit axis, 3 values

Questions/Feedback

Having problems with OpenRAVE?