openravepy_int Module¶

class openravepy.openravepy_int.AABB¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

__init__( (object)arg1, (object)pos, (object)extents) -> None

extents((AABB)arg1) → object¶

pos((AABB)arg1) → object¶

class openravepy.openravepy_int.CloningOptions¶

Bases: Boost.Python.enum

CloningOptions

Bodies = openravepy.openravepy_int.CloningOptions.Bodies¶

RealControllers = openravepy.openravepy_int.CloningOptions.RealControllers¶

Sensors = openravepy.openravepy_int.CloningOptions.Sensors¶

Simulation = openravepy.openravepy_int.CloningOptions.Simulation¶

Viewer = openravepy.openravepy_int.CloningOptions.Viewer¶

names = {'Viewer': openravepy.openravepy_int.CloningOptions.Viewer, 'RealControllers': openravepy.openravepy_int.CloningOptions.RealControllers, 'Sensors': openravepy.openravepy_int.CloningOptions.Sensors, 'Bodies': openravepy.openravepy_int.CloningOptions.Bodies, 'Simulation': openravepy.openravepy_int.CloningOptions.Simulation}¶

values = {8: openravepy.openravepy_int.CloningOptions.RealControllers, 1: openravepy.openravepy_int.CloningOptions.Bodies, 2: openravepy.openravepy_int.CloningOptions.Viewer, 4: openravepy.openravepy_int.CloningOptions.Simulation, 16: openravepy.openravepy_int.CloningOptions.Sensors}¶

class openravepy.openravepy_int.CollisionAction¶

Bases: Boost.Python.enum

CollisionAction

action to perform whenever a collision is detected between objects

DefaultAction = openravepy.openravepy_int.CollisionAction.DefaultAction¶

Ignore = openravepy.openravepy_int.CollisionAction.Ignore¶

names = {'DefaultAction': openravepy.openravepy_int.CollisionAction.DefaultAction, 'Ignore': openravepy.openravepy_int.CollisionAction.Ignore}¶

values = {0: openravepy.openravepy_int.CollisionAction.DefaultAction, 1: openravepy.openravepy_int.CollisionAction.Ignore}¶

class openravepy.openravepy_int.CollisionChecker¶

Bases: openravepy.openravepy_int.Interface

Raises an exception This class cannot be instantiated from Python

CheckCollision((CollisionChecker)arg1, (KinBody)body) → bool¶

CheckCollision( (CollisionChecker)arg1, (KinBody)body, (CollisionReport)report) -> bool

CheckCollision( (CollisionChecker)arg1, (KinBody)body1, (KinBody)body2) -> bool

CheckCollision( (CollisionChecker)arg1, (KinBody)body1, (KinBody)body2, (CollisionReport)report) -> bool

CheckCollision( (CollisionChecker)arg1, (object)link) -> bool

CheckCollision( (CollisionChecker)arg1, (object)link, (CollisionReport)report) -> bool

CheckCollision( (CollisionChecker)arg1, (object)link1, (object)link2) -> bool

CheckCollision( (CollisionChecker)arg1, (object)link1, (object)link2, (CollisionReport)report) -> bool

CheckCollision( (CollisionChecker)arg1, (object)link, (KinBody)body) -> bool

CheckCollision( (CollisionChecker)arg1, (object)link, (KinBody)body, (CollisionReport)report) -> bool

CheckCollision( (CollisionChecker)arg1, (object)link, (object)bodyexcluded, (object)linkexcluded) -> bool

CheckCollision( (CollisionChecker)arg1, (object)link, (object)bodyexcluded, (object)linkexcluded, (CollisionReport)report) -> bool

CheckCollision( (CollisionChecker)arg1, (KinBody)body, (object)bodyexcluded, (object)linkexcluded) -> bool

CheckCollision( (CollisionChecker)arg1, (KinBody)body, (object)bodyexcluded, (object)linkexcluded, (CollisionReport)report) -> bool

CheckCollision( (CollisionChecker)arg1, (Ray)ray, (KinBody)body) -> bool

CheckCollision( (CollisionChecker)arg1, (Ray)ray, (KinBody)body, (CollisionReport)report) -> bool

CheckCollision( (CollisionChecker)arg1, (Ray)ray) -> bool

CheckCollision( (CollisionChecker)arg1, (Ray)arg2, (CollisionReport)ray) -> bool

CheckCollisionRays((CollisionChecker)arg1, (object)rays, (KinBody)body[, (bool)front_facing_only]) → object :¶

Check if any rays hit the body and returns their contact points along with a vector specifying if a collision occured or not. Rays is a Nx6 array, first 3 columsn are position, last 3 are direction+range.

DestroyEnvironment((CollisionChecker)arg1) → None¶

GetCollisionOptions((CollisionChecker)arg1) → int :¶

int GetCollisionOptions()

get the current collision options

InitEnvironment((CollisionChecker)arg1) → bool¶

InitKinBody((CollisionChecker)arg1, (KinBody)arg2) → bool¶

RemoveKinBody((CollisionChecker)arg1, (KinBody)arg2) → None¶

SetCollisionOptions((CollisionChecker)arg1, (int)arg2) → bool :¶

bool SetCollisionOptions(int collisionoptions)

Set basic collision options using the CollisionOptions enum.

class openravepy.openravepy_int.CollisionOptions¶

Bases: Boost.Python.enum

CollisionOptions

options for collision checker

ActiveDOFs = openravepy.openravepy_int.CollisionOptions.ActiveDOFs¶

Contacts = openravepy.openravepy_int.CollisionOptions.Contacts¶

Distance = openravepy.openravepy_int.CollisionOptions.Distance¶

RayAnyHit = openravepy.openravepy_int.CollisionOptions.RayAnyHit¶

UseTolerance = openravepy.openravepy_int.CollisionOptions.UseTolerance¶

names = {'Distance': openravepy.openravepy_int.CollisionOptions.Distance, 'UseTolerance': openravepy.openravepy_int.CollisionOptions.UseTolerance, 'RayAnyHit': openravepy.openravepy_int.CollisionOptions.RayAnyHit, 'ActiveDOFs': openravepy.openravepy_int.CollisionOptions.ActiveDOFs, 'Contacts': openravepy.openravepy_int.CollisionOptions.Contacts}¶

values = {8: openravepy.openravepy_int.CollisionOptions.RayAnyHit, 1: openravepy.openravepy_int.CollisionOptions.Distance, 2: openravepy.openravepy_int.CollisionOptions.UseTolerance, 4: openravepy.openravepy_int.CollisionOptions.Contacts, 16: openravepy.openravepy_int.CollisionOptions.ActiveDOFs}¶

class openravepy.openravepy_int.CollisionReport¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

contacts¶

minDistance¶

numCols¶

numWithinTol¶

options¶

plink1¶

plink2¶

class openravepy.openravepy_int.ConfigurationSpecification¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

__init__( (object)arg1, (ConfigurationSpecification)spec) -> None

__init__( (object)arg1, (Group)group) -> None

__init__( (object)arg1, (str)xmldata) -> None

AddDeltaTimeGroup((ConfigurationSpecification)arg1) → int :¶

int AddDeltaTimeGroup()

adds the deltatime tag to the end if one doesn’t exist and returns the index into the configuration space

AddDerivativeGroups((ConfigurationSpecification)arg1, (int)arg2, (bool)adddeltatime) → None :¶

void AddDerivativeGroups(int deriv, bool adddeltatime = false )

adds velocity, acceleration, etc groups for every position group.

Parameters

deriv -

The position derivative to add, this must be greater than 0. If 2 is specified, only the acceleration groups of the alread present position groups will be added.

adddeltatime -

If true will add the ‘deltatime’ tag, which is necessary for trajectory sampling If the derivative groups already exist, they are checked for and/or modified. Note that the configuration space might be re-ordered as a result of this function call. If a new group is added, its interpolation will be the derivative of the position group as returned by GetInterpolationDerivative.

AddGroup((ConfigurationSpecification)arg1, (str)name, (int)dof, (str)interpolation) → int :¶

int AddGroup(const std::string & name, int dof, const std::string & interpolation = “” )

Adds a new group to the specification and returns its new offset.

If the new group’s semantic name does not exist in the current specification, adds it and returns the new offset. If the new group’s semantic name exists in the current specification and it exactly matches, then function returns the old group’s index. If the semantic names match, but parameters do not match, then an openrave_exception is thrown. This method is not responsible for merging semantic information

AddGroup( (ConfigurationSpecification)arg1, (Group)group) -> int :

int AddGroup(const Group & g)

Adds a new group to the specification and returns its new offset.

Parameters

g -

the group whose name, dof, and interpolation are extracted. If the new group’s semantic name does not exist in the current specification, adds it and returns the new offset. If the new group’s semantic name exists in the current specification and it exactly matches, then function returns the old group’s index. If the semantic names match, but parameters do not match, then an openrave_exception is thrown. This method is not responsible for merging semantic information

AddVelocityGroups((ConfigurationSpecification)arg1, (bool)adddeltatime) → None :¶

void AddVelocityGroups(bool adddeltatime)

ConvertToVelocitySpecification((ConfigurationSpecification)arg1) → ConfigurationSpecification :¶

ConfigurationSpecification ConvertToVelocitySpecification()

converts all the groups to the corresponding velocity groups and returns the specification

The velocity configuration space will have a one-to-one correspondence with the original configuration. The interpolation of each of the groups will correspondingly represent the derivative as returned by GetInterpolationDerivative. Only position specifications will be converted, any other groups will be left untouched.

ExtractDeltaTime((ConfigurationSpecification)arg1, (object)data) → object :¶

bool ExtractDeltaTime(dReal & deltatime, std::vector< dReal >::const_iterator itdata)

extracts the delta time from the configuration if one exists

Return

true if deltatime exists in the current configuration, otherwise false

ExtractJointValues((ConfigurationSpecification)arg1, (object)data, (KinBody)body, (object)indices[, (int)timederivative]) → object :¶

bool ExtractJointValues(std::vector< dReal >::iterator itvalues, std::vector< dReal >::const_iterator itdata, KinBodyConstPtr pbody, const std::vector< int > & indices, int timederivative = 0 )

extracts a body’s joint values given the start of a configuration space point

Parameters

inout] -

itvalues iterator to vector that holds the default values and will be overwritten with the new values. must be initialized

itdata -

data in the format of this configuration specification.

indices -

the set of DOF indices of the body to extract and write into itvalues.

timederivative -

the time derivative of the data to extract Looks for ‘joint_X’ groups. If pbody is not initialized, will choose the first joint_X found.

Return

true if at least one group was found for extracting

ExtractTransform((ConfigurationSpecification)arg1, (object)transform, (object)data, (KinBody)body[, (int)timederivative]) → object :¶

bool ExtractTransform(Transform & t, std::vector< dReal >::const_iterator itdata, KinBodyConstPtr pbody, int timederivative = 0 )

extracts an affine transform given the start of a configuration space point

Parameters

inout] -

t the transform holding the default values, which will be overwritten with the new values.

itdata -

data in the format of this configuration specification.

timederivative -

the time derivative of the data to extract Looks for ‘affine_transform’ groups. If pbody is not initialized, will choose the first affine_transform found.

Return

true if at least one group was found for extracting

FindCompatibleGroup((ConfigurationSpecification)arg1, (str)arg2, (bool)arg3) → object :¶

std::vector< Group >::const_iterator FindCompatibleGroup(const Group & g, bool exactmatch = false )

finds the most compatible group to the given group

Parameters

g -

the group to query, only the Group::name and Group::dof values are used

exactmatch -

if true, will only return groups whose name exactly matches with g.name

Return

an iterator part of _vgroups that represents the most compatible group. If no group is found, will return _vgroups.end()

FindTimeDerivativeGroup((ConfigurationSpecification)arg1, (str)arg2, (bool)arg3) → object :¶

std::vector< Group >::const_iterator FindTimeDerivativeGroup(const Group & g, bool exactmatch = false )

Return the most compatible group that represents the time-derivative data of the group.

Parameters

g -

the group to query, only the Group::name and Group::dof values are used

exactmatch -

if true, will only return groups whose name exactly matches with g.name For example given a ‘joint_values’ group, this will return the closest ‘joint_velocities’ group.

Return

an iterator part of _vgroups that represents the most compatible group. If no group is found, will return _vgroups.end()

GetDOF((ConfigurationSpecification)arg1) → int :¶

int GetDOF()

return the dimension of the configuraiton space (degrees of freedom)

GetGroupFromName((ConfigurationSpecification)arg1, (str)arg2) → Group :¶

const Group & GetGroupFromName(const std::string & name)

return the group whose name begins with a particular string.

Exceptions

openrave_exception -

if a group is not found If multiple groups exist that begin with the same string, then the shortest one is returned.

GetTimeDerivativeSpecification((ConfigurationSpecification)arg1, (int)arg2) → ConfigurationSpecification :¶

ConfigurationSpecification GetTimeDerivativeSpecification(int timederivative)

returns a new specification of just particular time-derivative groups.

Parameters

timederivative -

the time derivative to query groups from. 0 is positions/joint values, 1 is velocities, 2 is accelerations, etc

class Group¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

dof¶

interpolation¶

name¶

offset¶

ConfigurationSpecification.InsertDeltaTime((ConfigurationSpecification)arg1, (object)data, (float)deltatime) → bool :¶

bool InsertDeltaTime(std::vector< dReal >::iterator itdata, dReal deltatime)

sets the deltatime field of the data if one exists

Parameters

inout] -

itdata data in the format of this configuration specification.

deltatime -

the delta time of the time stamp (from previous point)

Return

true if at least one group was found for inserting

ConfigurationSpecification.InsertJointValues((ConfigurationSpecification)arg1, (object)data, (object)values, (KinBody)body, (object)indices, (int)timederivative) → bool¶

ConfigurationSpecification.IsValid((ConfigurationSpecification)arg1) → bool :¶

bool IsValid()

check if the groups form a continguous space

If there are two or more groups with the same semantic names, will fail. Theese groups should be merged into one.

Return

true if valid, otherwise false

ConfigurationSpecification.ResetGroupOffsets((ConfigurationSpecification)arg1) → None :¶

void ResetGroupOffsets()

set the offsets of each group in order to get a contiguous configuration space

class openravepy.openravepy_int.Contact¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

depth¶

norm¶

pos¶

class openravepy.openravepy_int.Controller¶

Bases: openravepy.openravepy_int.Interface

Raises an exception This class cannot be instantiated from Python

GetControlDOFIndices((Controller)arg1) → object :¶

const std::vector< int > & GetControlDOFIndices()

returns the dof indices controlled

GetRobot((Controller)arg1) → object :¶

RobotBasePtr GetRobot()

GetTime((Controller)arg1) → float :¶

dReal GetTime()

return the time along the current command

GetTorque((Controller)arg1) → object :¶

void GetTorque(std::vector< dReal > & torque)

Parameters

torque -

[out] - returns the current torque/current/strain exerted by each of the dofs from outside forces. The feedforward and friction terms should be subtracted out already get torque/current/strain values

GetVelocity((Controller)arg1) → object :¶

void GetVelocity(std::vector< dReal > & vel)

get velocity of the controlled DOFs

Parameters

vel -

[out] - current velocity of robot from the dof

Init((Controller)arg1, (Robot)arg2, (str)arg3) → bool :¶

bool Init(RobotBasePtr robot, const std::vector< int > & dofindices, int nControlTransformation)

initializes the controller and specifies the controlled dof

Parameters

robot -

the robot that uses the controller

dofindices -

the indices that controller will have exclusive access to

nControlTransformation -

See

IsControlTransformation

Return

true on successful initialization

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

bool Init(RobotBasePtr robot, const std::vector< int > & dofindices, int nControlTransformation)

initializes the controller and specifies the controlled dof

Parameters

robot -

the robot that uses the controller

dofindices -

the indices that controller will have exclusive access to

nControlTransformation -

See

IsControlTransformation

Return

true on successful initialization

IsControlTransformation((Controller)arg1) → int :¶

int IsControlTransformation()

returns non-zero value if base affine transformation is controlled.

Only one controller can modify translation and orientation per robot. For now, the two cannot be divided.

IsDone((Controller)arg1) → bool :¶

bool IsDone()

Return true when goal reached.

If a trajectory was set, return only when trajectory is done. If SetDesired was called, return only when robot is is at the desired location. If SendCommand sent, returns true when the command was completed by the hand.

Reset((Controller)arg1[, (int)options]) → None :¶

void Reset(int options = 0 )

Resets the current controller trajectories and any other state associated with the robot.

Parameters

options -

• specific options that can be used to control what to reset

SetDesired((Controller)arg1, (object)values) → bool :¶

bool SetDesired(const std::vector< dReal > & values, TransformConstPtr trans = TransformConstPtr () )

go to a specific position in configuration space.

Parameters

values -

the final configuration in the control dofs

trans -

the transformation of the base. If not specified will use the current robot transformation. Ignored if controller does not use it

Return

true if position operation successful.

SetDesired( (Controller)arg1, (object)values, (object)transform) -> bool :

bool SetDesired(const std::vector< dReal > & values, TransformConstPtr trans = TransformConstPtr () )

go to a specific position in configuration space.

Parameters

values -

the final configuration in the control dofs

trans -

the transformation of the base. If not specified will use the current robot transformation. Ignored if controller does not use it

Return

true if position operation successful.

SetPath((Controller)arg1, (Trajectory)arg2) → bool :¶

bool SetPath(TrajectoryBaseConstPtr ptraj)

Follow a path in configuration space, adds to the queue of trajectories already in execution.

Parameters

ptraj -

• the trajectory

Return

true if trajectory operation successful

SimulationStep((Controller)arg1, (float)arg2) → None :¶

void SimulationStep(dReal fTimeElapsed)

Simulate one step forward for controllers running in the simulation environment.

Parameters

fTimeElapsed -

• time elapsed in simulation environment since last frame

class openravepy.openravepy_int.DOFAffine¶

Bases: Boost.Python.enum

DOFAffine

Selects which DOFs of the affine transformation to include in the active configuration.

NoTransform = openravepy.openravepy_int.DOFAffine.NoTransform¶

Rotation3D = openravepy.openravepy_int.DOFAffine.Rotation3D¶

RotationAxis = openravepy.openravepy_int.DOFAffine.RotationAxis¶

RotationMask = openravepy.openravepy_int.DOFAffine.RotationMask¶

RotationQuat = openravepy.openravepy_int.DOFAffine.RotationQuat¶

Transform = openravepy.openravepy_int.DOFAffine.Transform¶

X = openravepy.openravepy_int.DOFAffine.X¶

Y = openravepy.openravepy_int.DOFAffine.Y¶

Z = openravepy.openravepy_int.DOFAffine.Z¶

names = {'NoTransform': openravepy.openravepy_int.DOFAffine.NoTransform, 'Rotation3D': openravepy.openravepy_int.DOFAffine.Rotation3D, 'RotationQuat': openravepy.openravepy_int.DOFAffine.RotationQuat, 'RotationAxis': openravepy.openravepy_int.DOFAffine.RotationAxis, 'Transform': openravepy.openravepy_int.DOFAffine.Transform, 'RotationMask': openravepy.openravepy_int.DOFAffine.RotationMask, 'Y': openravepy.openravepy_int.DOFAffine.Y, 'X': openravepy.openravepy_int.DOFAffine.X, 'Z': openravepy.openravepy_int.DOFAffine.Z}¶

values = {0: openravepy.openravepy_int.DOFAffine.NoTransform, 1: openravepy.openravepy_int.DOFAffine.X, 2: openravepy.openravepy_int.DOFAffine.Y, 4: openravepy.openravepy_int.DOFAffine.Z, 32: openravepy.openravepy_int.DOFAffine.RotationQuat, 8: openravepy.openravepy_int.DOFAffine.RotationAxis, 39: openravepy.openravepy_int.DOFAffine.Transform, 16: openravepy.openravepy_int.DOFAffine.Rotation3D, 56: openravepy.openravepy_int.DOFAffine.RotationMask}¶

class openravepy.openravepy_int.DebugLevel¶

Bases: Boost.Python.enum

DebugLevel

Debug = openravepy.openravepy_int.DebugLevel.Debug¶

Error = openravepy.openravepy_int.DebugLevel.Error¶

Fatal = openravepy.openravepy_int.DebugLevel.Fatal¶

Info = openravepy.openravepy_int.DebugLevel.Info¶

Verbose = openravepy.openravepy_int.DebugLevel.Verbose¶

VerifyPlans = openravepy.openravepy_int.DebugLevel.VerifyPlans¶

Warn = openravepy.openravepy_int.DebugLevel.Warn¶

names = {'Info': openravepy.openravepy_int.DebugLevel.Info, 'VerifyPlans': openravepy.openravepy_int.DebugLevel.VerifyPlans, 'Verbose': openravepy.openravepy_int.DebugLevel.Verbose, 'Warn': openravepy.openravepy_int.DebugLevel.Warn, 'Error': openravepy.openravepy_int.DebugLevel.Error, 'Debug': openravepy.openravepy_int.DebugLevel.Debug, 'Fatal': openravepy.openravepy_int.DebugLevel.Fatal}¶

values = {0: openravepy.openravepy_int.DebugLevel.Fatal, 1: openravepy.openravepy_int.DebugLevel.Error, 2: openravepy.openravepy_int.DebugLevel.Warn, 3: openravepy.openravepy_int.DebugLevel.Info, 4: openravepy.openravepy_int.DebugLevel.Debug, 5: openravepy.openravepy_int.DebugLevel.Verbose, 2147483648: openravepy.openravepy_int.DebugLevel.VerifyPlans}¶

class openravepy.openravepy_int.Environment¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

__init__( (object)arg1) -> None

Add((Environment)arg1, (Interface)interface[, (bool)anonymous[, (str)cmdargs]]) → None :¶

void Add(InterfaceBasePtr pinterface, bool bAnonymous = false , const std::string & cmdargs = “” )

Add an interface to the environment.

Parameters

pinterface -

the pointer to an initialized interface

bAnonymous -

if true and there exists a body/robot with the same name, will make body’s name unique

cmdargs -

The command-line arguments for the module. Exceptions

openrave_exception -

Throw if interface is invalid or already added Depending on the type of interface, the addition behaves differently. For bodies/robots, will add them to visual/geometric environment. For modules, will call their main() method and add them officially. For viewers, will attach a viewer to the environment and start sending it data. For interfaces that don’t make sense to add, will throw an exception.

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

void AddKinBody(KinBodyPtr body, bool bAnonymous = false )

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

void AddKinBody(KinBodyPtr body, bool bAnonymous = false )

AddModule((Environment)arg1, (Module)module, (str)args) → int :¶

int AddModule(ModuleBasePtr module, const std::string & cmdargs)

Load a new module, need to Lock if calling outside simulation thread.

AddRobot((Environment)arg1, (Robot)robot) → None :¶

void AddRobot(RobotBasePtr robot, bool bAnonymous = false )

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

void AddRobot(RobotBasePtr robot, bool bAnonymous = false )

AddSensor((Environment)arg1, (Sensor)sensor) → None :¶

void AddSensor(SensorBasePtr sensor, bool bAnonymous = false )

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

void AddSensor(SensorBasePtr sensor, bool bAnonymous = false )

AddViewer((Environment)arg1, (Sensor)sensor, (bool)anonymous) → None :¶

void AddViewer(ViewerBasePtr pviewer)

CheckCollision((Environment)arg1, (KinBody)body) → bool :¶

bool CheckCollision(KinBodyConstPtr pbody1, CollisionReportPtr report = CollisionReportPtr () )

See

CollisionCheckerBase::CheckCollision(KinBodyConstPtr,CollisionReportPtr)

CheckCollision( (Environment)arg1, (KinBody)body, (CollisionReport)report) -> bool :

bool CheckCollision(KinBodyConstPtr pbody1, CollisionReportPtr report = CollisionReportPtr () )

See

CollisionCheckerBase::CheckCollision(KinBodyConstPtr,CollisionReportPtr)

CheckCollision( (Environment)arg1, (KinBody)body1, (KinBody)body2) -> bool :

bool CheckCollision(KinBodyConstPtr pbody1, KinBodyConstPtr pbody2, CollisionReportPtr report = CollisionReportPtr () )

See

CollisionCheckerBase::CheckCollision(KinBodyConstPtr,KinBodyConstPtr,CollisionReportPtr)

CheckCollision( (Environment)arg1, (KinBody)body1, (KinBody)body2, (CollisionReport)report) -> bool :

bool CheckCollision(KinBodyConstPtr pbody1, KinBodyConstPtr pbody2, CollisionReportPtr report = CollisionReportPtr () )

See

CollisionCheckerBase::CheckCollision(KinBodyConstPtr,KinBodyConstPtr,CollisionReportPtr)

CheckCollision( (Environment)arg1, (object)link) -> bool :

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

See

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

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

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

See

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

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

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

See

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

CheckCollision( (Environment)arg1, (object)link1, (object)link2, (CollisionReport)report) -> bool :

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

See

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

CheckCollision( (Environment)arg1, (object)link, (KinBody)body) -> bool :

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

See

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

CheckCollision( (Environment)arg1, (object)link, (KinBody)body, (CollisionReport)report) -> bool :

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

See

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

CheckCollision( (Environment)arg1, (object)link, (object)bodyexcluded, (object)linkexcluded) -> bool :

bool CheckCollision(KinBody::LinkConstPtr plink, const std::vector< KinBodyConstPtr > & vbodyexcluded, const std::vector< KinBody::LinkConstPtr > & vlinkexcluded, CollisionReportPtr report = CollisionReportPtr () )

See

CollisionCheckerBase::CheckCollision(KinBody::LinkConstPtr,const std::vector<KinBodyConstPtr>&,const std::vector<KinBody::LinkConstPtr>&,CollisionReportPtr)

CheckCollision( (Environment)arg1, (object)link, (object)bodyexcluded, (object)linkexcluded, (CollisionReport)report) -> bool :

bool CheckCollision(KinBody::LinkConstPtr plink, const std::vector< KinBodyConstPtr > & vbodyexcluded, const std::vector< KinBody::LinkConstPtr > & vlinkexcluded, CollisionReportPtr report = CollisionReportPtr () )

See

CollisionCheckerBase::CheckCollision(KinBody::LinkConstPtr,const std::vector<KinBodyConstPtr>&,const std::vector<KinBody::LinkConstPtr>&,CollisionReportPtr)

CheckCollision( (Environment)arg1, (KinBody)body, (object)bodyexcluded, (object)linkexcluded) -> bool :

bool CheckCollision(KinBodyConstPtr pbody, const std::vector< KinBodyConstPtr > & vbodyexcluded, const std::vector< KinBody::LinkConstPtr > & vlinkexcluded, CollisionReportPtr report = CollisionReportPtr () )

See

CollisionCheckerBase::CheckCollision(KinBodyConstPtr,const std::vector<KinBodyConstPtr>&,const std::vector<KinBody::LinkConstPtr>&,CollisionReportPtr)

CheckCollision( (Environment)arg1, (KinBody)body, (object)bodyexcluded, (object)linkexcluded, (CollisionReport)report) -> bool :

bool CheckCollision(KinBodyConstPtr pbody, const std::vector< KinBodyConstPtr > & vbodyexcluded, const std::vector< KinBody::LinkConstPtr > & vlinkexcluded, CollisionReportPtr report = CollisionReportPtr () )

See

CollisionCheckerBase::CheckCollision(KinBodyConstPtr,const std::vector<KinBodyConstPtr>&,const std::vector<KinBody::LinkConstPtr>&,CollisionReportPtr)

CheckCollision( (Environment)arg1, (Ray)ray, (KinBody)body) -> bool :

bool CheckCollision(const RAY & ray, KinBodyConstPtr pbody, CollisionReportPtr report = CollisionReportPtr () )

See

CollisionCheckerBase::CheckCollision(const RAY&,KinBodyConstPtr,CollisionReportPtr)

CheckCollision( (Environment)arg1, (Ray)ray, (KinBody)body, (CollisionReport)report) -> bool :

bool CheckCollision(const RAY & ray, KinBodyConstPtr pbody, CollisionReportPtr report = CollisionReportPtr () )

See

CollisionCheckerBase::CheckCollision(const RAY&,KinBodyConstPtr,CollisionReportPtr)

CheckCollision( (Environment)arg1, (Ray)ray) -> bool :

bool CheckCollision(const RAY & ray, CollisionReportPtr report = CollisionReportPtr () )

See

CollisionCheckerBase::CheckCollision(const RAY&,CollisionReportPtr)

CheckCollision( (Environment)arg1, (Ray)arg2, (CollisionReport)ray) -> bool :

bool CheckCollision(const RAY & ray, CollisionReportPtr report = CollisionReportPtr () )

See

CollisionCheckerBase::CheckCollision(const RAY&,CollisionReportPtr)

CheckCollisionRays((Environment)arg1, (object)rays, (KinBody)body[, (bool)front_facing_only]) → object :¶

Check if any rays hit the body and returns their contact points along with a vector specifying if a collision occured or not. Rays is a Nx6 array, first 3 columsn are position, last 3 are direction+range.

Clone((Environment)arg1, (Environment)reference, (int)options) → None :¶

void Clone(EnvironmentBaseConstPtr preference, int cloningoptions)

Clones the reference environment into the current environment.

Parameters

cloningoptions -

The parts of the environment to clone. Parts not specified are left as is. Tries to preserve computation by re-using bodies/interfaces that are already similar between the current and reference environments.

CloneSelf((Environment)arg1, (int)options) → Environment :¶

EnvironmentBasePtr CloneSelf(int options)

Create and return a clone of the current environment.

Parameters

options -

A set of CloningOptions describing what is actually cloned. Clones do not share any memory or resource between each other. or their parent making them ideal for performing separte planning experiments while keeping the parent environment unchanged. By default a clone only copies the collision checkers and physics engine. When bodies are cloned, the unique ids are preserved across environments (each body can be referenced with its id in both environments). The attached and grabbed bodies of each body/robot are also copied to the new environment.

Return

An environment of the same type as this environment containing the copied information.

Destroy((Environment)arg1) → None :¶

void Destroy()

Releases all environment resources, should be always called when environment stops being used.

Removing all environment pointer might not be enough to destroy the environment resources.

GetBodies((Environment)arg1) → object :¶

void GetBodies(std::vector< KinBodyPtr > & bodies, uint64_t timeout = 0 )

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

Parameters

bodies -

filled with all the bodies

timeout -

microseconds to wait before throwing an exception, if 0, will block indefinitely. Exceptions

openrave_exception -

with ORE_Timeout error code A separate is locked for reading the bodies.

GetBodyFromEnvironmentId((Environment)arg1, (int)arg2) → object :¶

KinBodyPtr GetBodyFromEnvironmentId(int id)

Get the corresponding body from its unique network id.

GetCollisionChecker((Environment)arg1) → object :¶

CollisionCheckerBasePtr GetCollisionChecker()

GetDebugLevel((Environment)arg1) → int :¶

int GetDebugLevel()

GetHomeDirectory((Environment)arg1) → str :¶

std::string GetHomeDirectory()

GetKinBody((Environment)arg1, (str)name) → object :¶

KinBodyPtr GetKinBody(const std::string & name)

Query a body from its name.

Return

first KinBody (including robots) that matches with name

GetLoadedProblems((Environment)arg1) → object :¶

void GetModules(std::list< ModuleBasePtr > & listModules, uint64_t timeout = 0 )

Fills a list with the loaded modules in the environment.

Parameters

timeout -

microseconds to wait before throwing an exception, if 0, will block indefinitely. Exceptions

openrave_exception -

with ORE_Timeout error code A separate is locked for reading the modules. If the environment is locked, the modules are guaranteed to stay loaded in the environment.

GetModules((Environment)arg1) → object :¶

void GetModules(std::list< ModuleBasePtr > & listModules, uint64_t timeout = 0 )

Fills a list with the loaded modules in the environment.

Parameters

timeout -

microseconds to wait before throwing an exception, if 0, will block indefinitely. Exceptions

openrave_exception -

with ORE_Timeout error code A separate is locked for reading the modules. If the environment is locked, the modules are guaranteed to stay loaded in the environment.

GetPhysicsEngine((Environment)arg1) → object :¶

PhysicsEngineBasePtr GetPhysicsEngine()

GetRobot((Environment)arg1, (str)name) → object :¶

RobotBasePtr GetRobot(const std::string & name)

Query a robot from its name.

Return

first Robot that matches the name

GetRobots((Environment)arg1) → object :¶

void GetRobots(std::vector< RobotBasePtr > & robots, uint64_t timeout = 0 )

Fill an array with all robots loaded in the environment.

Parameters

timeout -

microseconds to wait before throwing an exception, if 0, will block indefinitely. Exceptions

openrave_exception -

with ORE_Timeout error code A separate is locked for reading the bodies.

GetSensor((Environment)arg1, (str)name) → object :¶

SensorBasePtr GetSensor(const std::string & name)

Query a sensor from its name.

Return

first sensor that matches with name, note that sensors attached to robots have the robot name as a prefix.

GetSensors((Environment)arg1) → object :¶

void GetSensors(std::vector< SensorBasePtr > & sensors, uint64_t timeout = 0 )

Fill an array with all sensors loaded in the environment.

Parameters

timeout -

microseconds to wait before throwing an exception, if 0, will block indefinitely. Exceptions

openrave_exception -

with ORE_Timeout error code The sensors come from the currently loaded robots and the explicitly added sensors

GetSimulationTime((Environment)arg1) → int :¶

uint64_t GetSimulationTime()

Return simulation time since the start of the environment (in microseconds).

See Simulation Thread for more about the simulation thread.

GetUserData((Environment)arg1) → object :¶

UserDataPtr GetUserData()

return the user custom data

GetViewer((Environment)arg1) → object :¶

ViewerBasePtr GetViewer(const std::string & name = “” )

Return a viewer with a particular name.

When no name is specified, the first loaded viewer is returned.

HasRegisteredCollisionCallbacks((Environment)arg1) → bool¶

IsSimulationRunning((Environment)arg1) → bool¶

Load((Environment)arg1, (str)filename) → bool :¶

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

Loads a scene from a file and adds all objects in the environment.

For collada readers, the options are passed through to

Load( (Environment)arg1, (str)filename, (object)atts) -> bool :

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

Loads a scene from a file and adds all objects in the environment.

For collada readers, the options are passed through to

LoadData((Environment)arg1, (str)data) → bool :¶

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

Loads a scene from in-memory data and adds all objects in the environment.

LoadData( (Environment)arg1, (str)data, (object)atts) -> bool :

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

Loads a scene from in-memory data and adds all objects in the environment.

LoadProblem((Environment)arg1, (Module)module, (str)args) → int :¶

int AddModule(ModuleBasePtr module, const std::string & cmdargs)

Load a new module, need to Lock if calling outside simulation thread.

LoadURI((Environment)arg1, (str)filename[, (object)atts]) → bool :¶

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

Loads a scene from a URI and adds all objects in the environment.

Currently only collada files are supported. Options are passed through to

Lock((Environment)arg1) → None :¶

Locks the environment mutex.

LockPhysics((Environment)lock) → None :¶

Locks the environment mutex.

LockPhysics( (Environment)lock, (float)timeout) -> None :

Locks the environment mutex with a timeout.

ReadInterfaceURI((Environment)arg1, (str)filename) → Interface :¶

InterfaceBasePtr ReadInterfaceURI(InterfaceBasePtr pinterface, InterfaceType type, const std::string & filename, const AttributesList & atts = AttributesList () )

Initializes an interface from a resource file.

Parameters

pinterface -

If a null pointer is passed, a new interface will be created, otherwise an existing interface will be filled

filename -

the name of the resource file, its extension determines the format of the file. See Resource File Formats.

atts -

The attribute/value pair specifying loading options. See the individual interface descriptions at Base Interface Concepts.

ReadInterfaceURI( (Environment)arg1, (str)filename, (object)atts) -> Interface :

InterfaceBasePtr ReadInterfaceURI(InterfaceBasePtr pinterface, InterfaceType type, const std::string & filename, const AttributesList & atts = AttributesList () )

Initializes an interface from a resource file.

Parameters

pinterface -

If a null pointer is passed, a new interface will be created, otherwise an existing interface will be filled

filename -

the name of the resource file, its extension determines the format of the file. See Resource File Formats.

atts -

The attribute/value pair specifying loading options. See the individual interface descriptions at Base Interface Concepts.

ReadInterfaceXMLFile((Environment)arg1, (str)filename) → Interface :¶

InterfaceBasePtr ReadInterfaceURI(InterfaceBasePtr pinterface, InterfaceType type, const std::string & filename, const AttributesList & atts = AttributesList () )

Initializes an interface from a resource file.

Parameters

pinterface -

If a null pointer is passed, a new interface will be created, otherwise an existing interface will be filled

filename -

the name of the resource file, its extension determines the format of the file. See Resource File Formats.

atts -

The attribute/value pair specifying loading options. See the individual interface descriptions at Base Interface Concepts.

ReadInterfaceXMLFile( (Environment)arg1, (str)filename, (object)atts) -> Interface :

InterfaceBasePtr ReadInterfaceURI(InterfaceBasePtr pinterface, InterfaceType type, const std::string & filename, const AttributesList & atts = AttributesList () )

Initializes an interface from a resource file.

Parameters

pinterface -

If a null pointer is passed, a new interface will be created, otherwise an existing interface will be filled

filename -

the name of the resource file, its extension determines the format of the file. See Resource File Formats.

atts -

The attribute/value pair specifying loading options. See the individual interface descriptions at Base Interface Concepts.

ReadKinBodyData((Environment)arg1, (str)data) → object :¶

KinBodyPtr ReadKinBodyData(KinBodyPtr body, const std::string & data, const AttributesList & atts = AttributesList () )

Initializes a kinematic body from in-memory data.

Parameters

body -

If a null pointer is passed, a new body will be created, otherwise an existing robot will be filled

atts -

The attribute/value pair specifying loading options. Defined in Kinematics Body Concepts. The body should not be added to the environment when calling this function.

ReadKinBodyData( (Environment)arg1, (str)data, (object)atts) -> object :

KinBodyPtr ReadKinBodyData(KinBodyPtr body, const std::string & data, const AttributesList & atts = AttributesList () )

Initializes a kinematic body from in-memory data.

Parameters

body -

If a null pointer is passed, a new body will be created, otherwise an existing robot will be filled

atts -

The attribute/value pair specifying loading options. Defined in Kinematics Body Concepts. The body should not be added to the environment when calling this function.

ReadKinBodyURI((Environment)arg1, (str)filename) → object :¶

KinBodyPtr ReadKinBodyURI(const std::string & filename)

Creates a new kinbody from an XML file with no extra load options specified.

ReadKinBodyURI( (Environment)arg1, (str)filename, (object)atts) -> object :

KinBodyPtr ReadKinBodyURI(KinBodyPtr body, const std::string & filename, const AttributesList & atts = AttributesList () )

Initializes a kinematic body from a resource file. The body is not added to the environment when calling this function.

Parameters

filename -

the name of the resource file, its extension determines the format of the file. See Resource File Formats.

body -

If a null pointer is passed, a new body will be created, otherwise an existing robot will be filled

atts -

The attribute/value pair specifying loading options. Defined in Kinematics Body Concepts.

ReadKinBodyXMLData((Environment)arg1, (str)data) → object :¶

KinBodyPtr ReadKinBodyData(KinBodyPtr body, const std::string & data, const AttributesList & atts = AttributesList () )

Initializes a kinematic body from in-memory data.

Parameters

body -

If a null pointer is passed, a new body will be created, otherwise an existing robot will be filled

atts -

The attribute/value pair specifying loading options. Defined in Kinematics Body Concepts. The body should not be added to the environment when calling this function.

ReadKinBodyXMLData( (Environment)arg1, (str)data, (object)atts) -> object :

KinBodyPtr ReadKinBodyData(KinBodyPtr body, const std::string & data, const AttributesList & atts = AttributesList () )

Initializes a kinematic body from in-memory data.

Parameters

body -

If a null pointer is passed, a new body will be created, otherwise an existing robot will be filled

atts -

The attribute/value pair specifying loading options. Defined in Kinematics Body Concepts. The body should not be added to the environment when calling this function.

ReadKinBodyXMLFile((Environment)arg1, (str)filename) → object :¶

KinBodyPtr ReadKinBodyURI(const std::string & filename)

Creates a new kinbody from an XML file with no extra load options specified.

ReadKinBodyXMLFile( (Environment)arg1, (str)filename, (object)atts) -> object :

KinBodyPtr ReadKinBodyURI(KinBodyPtr body, const std::string & filename, const AttributesList & atts = AttributesList () )

Initializes a kinematic body from a resource file. The body is not added to the environment when calling this function.

Parameters

filename -

the name of the resource file, its extension determines the format of the file. See Resource File Formats.

body -

If a null pointer is passed, a new body will be created, otherwise an existing robot will be filled

atts -

The attribute/value pair specifying loading options. Defined in Kinematics Body Concepts.

ReadRobotData((Environment)arg1, (str)data) → object :¶

RobotBasePtr ReadRobotData(RobotBasePtr robot, const std::string & data, const AttributesList & atts = AttributesList () )

Initialize a robot from in-memory data.

Parameters

robot -

If a null pointer is passed, a new robot will be created, otherwise an existing robot will be filled

atts -

The attribute/value pair specifying loading options. Defined in Robot Concepts. The robot should not be added the environment when calling this function.

ReadRobotData( (Environment)arg1, (str)data, (object)atts) -> object :

RobotBasePtr ReadRobotData(RobotBasePtr robot, const std::string & data, const AttributesList & atts = AttributesList () )

Initialize a robot from in-memory data.

Parameters

robot -

If a null pointer is passed, a new robot will be created, otherwise an existing robot will be filled

atts -

The attribute/value pair specifying loading options. Defined in Robot Concepts. The robot should not be added the environment when calling this function.

ReadRobotURI((Environment)arg1, (str)filename) → object :¶

RobotBasePtr ReadRobotURI(const std::string & filename)

Creates a new robot from a file with no extra load options specified.

ReadRobotURI( (Environment)arg1, (str)filename, (object)atts) -> object :

RobotBasePtr ReadRobotURI(RobotBasePtr robot, const std::string & filename, const AttributesList & atts = AttributesList () )

Initializes a robot from a resource file. The robot is not added to the environment when calling this function.

Parameters

robot -

If a null pointer is passed, a new robot will be created, otherwise an existing robot will be filled

filename -

the name of the resource file, its extension determines the format of the file. See Resource File Formats.

atts -

The attribute/value pair specifying loading options. Defined in Robot Concepts.

ReadRobotXMLData((Environment)arg1, (str)data) → object :¶

RobotBasePtr ReadRobotData(RobotBasePtr robot, const std::string & data, const AttributesList & atts = AttributesList () )

Initialize a robot from in-memory data.

Parameters

robot -

If a null pointer is passed, a new robot will be created, otherwise an existing robot will be filled

atts -

The attribute/value pair specifying loading options. Defined in Robot Concepts. The robot should not be added the environment when calling this function.

ReadRobotXMLData( (Environment)arg1, (str)data, (object)atts) -> object :

RobotBasePtr ReadRobotData(RobotBasePtr robot, const std::string & data, const AttributesList & atts = AttributesList () )

Initialize a robot from in-memory data.

Parameters

robot -

If a null pointer is passed, a new robot will be created, otherwise an existing robot will be filled

atts -

The attribute/value pair specifying loading options. Defined in Robot Concepts. The robot should not be added the environment when calling this function.

ReadRobotXMLFile((Environment)arg1, (str)filename) → object :¶

RobotBasePtr ReadRobotURI(const std::string & filename)

Creates a new robot from a file with no extra load options specified.

ReadRobotXMLFile( (Environment)arg1, (str)filename, (object)atts) -> object :

RobotBasePtr ReadRobotURI(RobotBasePtr robot, const std::string & filename, const AttributesList & atts = AttributesList () )

Initializes a robot from a resource file. The robot is not added to the environment when calling this function.

Parameters

robot -

If a null pointer is passed, a new robot will be created, otherwise an existing robot will be filled

filename -

the name of the resource file, its extension determines the format of the file. See Resource File Formats.

atts -

The attribute/value pair specifying loading options. Defined in Robot Concepts.

ReadTrimeshFile((Environment)arg1, (str)filename) → object :¶

boost::shared_ptr< KinBody::Link::TRIMESH > ReadTrimeshURI(boost::shared_ptr< KinBody::Link::TRIMESH > ptrimesh, const std::string & filename, const AttributesList & atts = AttributesList () )

reads in the rigid geometry of a resource file into a TRIMESH structure

Parameters

filename -

the name of the resource file, its extension determines the format of the file. Complex meshes and articulated meshes are all triangulated appropriately. See Resource File Formats.

options -

Options to control the parsing process.

ReadTrimeshFile( (Environment)arg1, (str)filename, (object)atts) -> object :

boost::shared_ptr< KinBody::Link::TRIMESH > ReadTrimeshURI(boost::shared_ptr< KinBody::Link::TRIMESH > ptrimesh, const std::string & filename, const AttributesList & atts = AttributesList () )

reads in the rigid geometry of a resource file into a TRIMESH structure

Parameters

filename -

the name of the resource file, its extension determines the format of the file. Complex meshes and articulated meshes are all triangulated appropriately. See Resource File Formats.

options -

Options to control the parsing process.

ReadTrimeshURI((Environment)arg1, (str)filename) → object :¶

boost::shared_ptr< KinBody::Link::TRIMESH > ReadTrimeshURI(boost::shared_ptr< KinBody::Link::TRIMESH > ptrimesh, const std::string & filename, const AttributesList & atts = AttributesList () )

reads in the rigid geometry of a resource file into a TRIMESH structure

Parameters

filename -

the name of the resource file, its extension determines the format of the file. Complex meshes and articulated meshes are all triangulated appropriately. See Resource File Formats.

options -

Options to control the parsing process.

ReadTrimeshURI( (Environment)arg1, (str)filename, (object)atts) -> object :

boost::shared_ptr< KinBody::Link::TRIMESH > ReadTrimeshURI(boost::shared_ptr< KinBody::Link::TRIMESH > ptrimesh, const std::string & filename, const AttributesList & atts = AttributesList () )

reads in the rigid geometry of a resource file into a TRIMESH structure

Parameters

filename -

the name of the resource file, its extension determines the format of the file. Complex meshes and articulated meshes are all triangulated appropriately. See Resource File Formats.

options -

Options to control the parsing process.

RegisterCollisionCallback((Environment)arg1, (object)callback) → object :¶

UserDataPtr RegisterCollisionCallback(const CollisionCallbackFn & callback)

Register a collision callback.Whenever a collision is detected between between bodies during a CheckCollision call or physics simulation, the callback is called. The callback should return an action specifying how the collision should be handled:

Return

a handle to the registration, once the handle loses scope, the callback is unregistered

Remove((Environment)arg1, (Interface)interface) → bool :¶

bool Remove(InterfaceBasePtr obj)

Removes a currently loaded interface from the environment.

Parameters

obj -

interface to remove The function removes currently loaded bodies, robots, sensors, problems from the actively used interfaces of the environment. This does not destroy the interface, but it does remove all references managed. Some interfaces like problems have destroy methods that are called to signal unloading. Note that the active interfaces are different from the owned interfaces.

Return

true if the interface was successfully removed from the environment.

RemoveKinBody((Environment)arg1, (KinBody)body) → bool :¶

bool RemoveKinBody(KinBodyPtr pbody)

remove body from sensory system. If bDestroy is true, will also deallocate the memory

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

Reset((Environment)arg1) → None :¶

void Reset()

Resets all objects of the scene (preserves all problems, planners).

Do not call inside a SimulationStep call

Save((Environment)arg1, (str)filename[, (SelectionOptions)options[, (object)atts]]) → None :¶

void Save(const std::string & filename, SelectionOptions options = SO_Everything , const AttributesList & atts = AttributesList () )

Saves a scene depending on the filename extension. Default is in COLLADA format.

Parameters

filename -

the filename to save the results at

options -

controls what to save

atts -

attributes that refine further options. For collada parsing, the options are passed through Several default options are: Exceptions

openrave_exception -

Throw if failed to save anything

class SelectionOptions¶

Bases: Boost.Python.enum

SelectionOptions

A set of options used to select particular parts of the scene.

AllExceptBody = openravepy.openravepy_int.SelectionOptions.AllExceptBody¶

Body = openravepy.openravepy_int.SelectionOptions.Body¶

Everything = openravepy.openravepy_int.SelectionOptions.Everything¶

NoRobots = openravepy.openravepy_int.SelectionOptions.NoRobots¶

Robots = openravepy.openravepy_int.SelectionOptions.Robots¶

names = {'Body': openravepy.openravepy_int.SelectionOptions.Body, 'Everything': openravepy.openravepy_int.SelectionOptions.Everything, 'Robots': openravepy.openravepy_int.SelectionOptions.Robots, 'NoRobots': openravepy.openravepy_int.SelectionOptions.NoRobots, 'AllExceptBody': openravepy.openravepy_int.SelectionOptions.AllExceptBody}¶

values = {1: openravepy.openravepy_int.SelectionOptions.NoRobots, 2: openravepy.openravepy_int.SelectionOptions.Robots, 3: openravepy.openravepy_int.SelectionOptions.Everything, 4: openravepy.openravepy_int.SelectionOptions.Body, 5: openravepy.openravepy_int.SelectionOptions.AllExceptBody}¶

Environment.SetCollisionChecker((Environment)arg1, (CollisionChecker)collisionchecker) → bool :¶

bool SetCollisionChecker(CollisionCheckerBasePtr pchecker)

set the global environment collision checker

Environment.SetDebugLevel((Environment)arg1, (object)level) → None :¶

void SetDebugLevel(int level)

Parameters

level -

0 for no debug, 1 - to print all debug messeges. Default value for release builds is 0, for debug builds it is 1 declaring variables with stdcall can be a little complex sets the debug level

Environment.SetPhysicsEngine((Environment)arg1, (PhysicsEngine)physics) → bool :¶

bool SetPhysicsEngine(PhysicsEngineBasePtr physics)

Parameters

physics -

the engine to set, if NULL, environment sets an dummy physics engine set the physics engine, disabled by default

Environment.SetUserData((Environment)arg1, (UserData)data) → None :¶

void SetUserData(UserDataPtr data)

set user data

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

void SetUserData(UserDataPtr data)

set user data

Environment.SetViewer((Environment)arg1, (str)viewername[, (bool)showviewer]) → bool :¶

Attaches the viewer and starts its thread

Environment.StartSimulation((Environment)arg1, (float)timestep[, (bool)realtime]) → None :¶

void StartSimulation(dReal fDeltaTime, bool bRealTime = true )

Start the internal simulation thread.

Resets simulation time to 0. See Simulation Thread for more about the simulation thread.Parameters

fDeltaTime -

the delta step to take in simulation

bRealTime -

if false will call SimulateStep as fast as possible, otherwise will time the simulate step calls so that simulation progresses with real system time.

Environment.StepSimulation((Environment)arg1, (float)timestep) → None :¶

void StepSimulation(dReal timeStep)

Makes one simulation time step.

Can be called manually by the user inside planners. Keep in mind that the internal simulation thread also calls this function periodically. See Simulation Thread for more about the simulation thread.

Environment.StopSimulation((Environment)arg1) → None :¶

void StopSimulation()

Stops the internal physics loop, stops calling SimulateStep for all modules.

See Simulation Thread for more about the simulation thread.

Environment.Triangulate((Environment)arg1, (KinBody)body) → object :¶

void Triangulate(KinBody::Link::TRIMESH & trimesh, KinBodyConstPtr pbody)

Triangulation of the body including its current transformation. trimesh will be appended the new data.

Parameters

trimesh -

• The output triangle mesh

body -

body the triangulate Exceptions

openrave_exception -

Throw if failed to add anything

Environment.TriangulateOptions¶

alias of SelectionOptions

Environment.TriangulateScene((Environment)arg1, (SelectionOptions)options, (str)name) → object :¶

void TriangulateScene(KinBody::Link::TRIMESH & trimesh, SelectionOptions options, const std::string & selectname)

General triangulation of the whole scene.

Parameters

trimesh -

• The output triangle mesh. The new triangles are appended to the existing triangles!

options -

• Controlls what to triangulate.

selectname -

• name of the body used in options Exceptions

openrave_exception -

Throw if failed to add anything

Environment.Unlock((Environment)arg1) → None :¶

Unlocks the environment mutex.

Environment.UpdatePublishedBodies((Environment)arg1) → None :¶

void UpdatePublishedBodies(uint64_t timeout = 0 )

Updates the published bodies that viewers and other programs listening in on the environment see.

Parameters

timeout -

microseconds to wait before throwing an exception, if 0, will block indefinitely. Exceptions

openrave_exception -

with ORE_Timeout error code For example, calling this function inside a planning loop allows the viewer to update the environment reflecting the status of the planner. Assumes that the physics are locked.

Environment.drawarrow((Environment)arg1, (object)p1, (object)p2[, (float)linewidth[, (object)color]]) → object :¶

OpenRAVE::GraphHandlePtr drawarrow(const RaveVector< float > & p1, const RaveVector< float > & p2, float fwidth, const RaveVector< float > & color = RaveVector< float >(1, 0.5, 0.5, 1) )

Draws an arrow p1 is start, p2 is finish.

Parameters

color -

the rgb color of the point. The last component of the color is used for alpha blending.

Return

handle to plotted points, graph is removed when handle is destroyed (goes out of scope). This requires the user to always store the handle in a persistent variable if the plotted graphics are to remain on the viewer.

Environment.drawbox((Environment)arg1, (object)pos, (object)extents[, (object)color]) → object :¶

OpenRAVE::GraphHandlePtr drawbox(const RaveVector< float > & vpos, const RaveVector< float > & vextents)

Draws a box.

extents are half the width, height, and depth of the box

Return

handle to plotted points, graph is removed when handle is destroyed (goes out of scope). This requires the user to always store the handle in a persistent variable if the plotted graphics are to remain on the viewer.

Environment.drawlinelist((Environment)arg1, (object)points, (float)linewidth[, (object)colors[, (int)drawstyle]]) → object :¶

OpenRAVE::GraphHandlePtr drawlinelist(const float * ppoints, int numPoints, int stride, float fwidth, const float * colors)

Draws a list of individual lines, each specified by a succeeding pair of points.

Parameters

stride -

stride in bytes to next point, ie: nextpoint = (float*)((char*)ppoints+stride)

Return

handle to plotted points, graph is removed when handle is destroyed (goes out of scope). This requires the user to always store the handle in a persistent variable if the plotted graphics are to remain on the viewer.

Environment.drawlinestrip((Environment)arg1, (object)points, (float)linewidth[, (object)colors[, (int)drawstyle]]) → object :¶

OpenRAVE::GraphHandlePtr drawlinestrip(const float * ppoints, int numPoints, int stride, float fwidth, const float * colors)

Draws a series of connected lines with individual colors.

Parameters

stride -

stride in bytes to next point, ie: nextpoint = (float*)((char*)ppoints+stride)

Return

handle to plotted points, graph is removed when handle is destroyed (goes out of scope). This requires the user to always store the handle in a persistent variable if the plotted graphics are to remain on the viewer.

Environment.drawplane((Environment)arg1, (object)transform, (object)extents, (object)texture) → object :¶

OpenRAVE::GraphHandlePtr drawplane(const RaveTransform < float > & tplane, const RaveVector< float > & vextents, const boost::multi_array< float, 3 > & vtexture)

Draws a textured plane.

Parameters

tplane -

describes the center of the plane. the zaxis of this coordinate is the normal of the plane

vextents -

the extents of the plane along the x and y directions (z is ignored)

vtexture -

a 3D array specifying height x width x color (the color dimension can be 1, 3, or 4 (for alpha blending))

Return

handle to plotted points, graph is removed when handle is destroyed (goes out of scope). This requires the user to always store the handle in a persistent variable if the plotted graphics are to remain on the viewer.

drawplane( (Environment)arg1, (object)transform, (object)extents, (object)texture) -> object :

OpenRAVE::GraphHandlePtr drawplane(const RaveTransform < float > & tplane, const RaveVector< float > & vextents, const boost::multi_array< float, 3 > & vtexture)

Draws a textured plane.

Parameters

tplane -

describes the center of the plane. the zaxis of this coordinate is the normal of the plane

vextents -

the extents of the plane along the x and y directions (z is ignored)

vtexture -

a 3D array specifying height x width x color (the color dimension can be 1, 3, or 4 (for alpha blending))

Return

handle to plotted points, graph is removed when handle is destroyed (goes out of scope). This requires the user to always store the handle in a persistent variable if the plotted graphics are to remain on the viewer.

Environment.drawtrimesh((Environment)arg1, (object)points[, (object)indices[, (object)colors]]) → object :¶

OpenRAVE::GraphHandlePtr drawtrimesh(const float * ppoints, int stride, const int * pIndices, int numTriangles, const boost::multi_array< float, 2 > & colors)

Draws a triangle mesh, each vertices of each triangle should be counter-clockwise.

Parameters

ppoints -

• array of 3D points

stride -

stride in bytes to next point, ie: nextpoint = (float*)((char*)ppoints+stride)

pIndices -

If not NULL, zero-based indices into the points for every triangle. pIndices should be of size numTriangles. If pIndices is NULL, ppoints is assumed to contain numTriangles*3 points and triangles will be rendered in list order.

color -

The color of the triangle. The last component of the color is used for alpha blending

Return

handle to plotted points, graph is removed when handle is destroyed (goes out of scope). This requires the user to always store the handle in a persistent variable if the plotted graphics are to remain on the viewer.

Environment.plot3((Environment)arg1, (object)points, (float)pointsize[, (object)colors[, (int)drawstyle]]) → object¶

class openravepy.openravepy_int.ErrorCode¶

Bases: Boost.Python.enum

OpenRAVEErrorCode

OpenRAVE error codes

Assert = openravepy.openravepy_int.ErrorCode.Assert¶

CommandNotSupported = openravepy.openravepy_int.ErrorCode.CommandNotSupported¶

EnvironmentNotLocked = openravepy.openravepy_int.ErrorCode.EnvironmentNotLocked¶

Failed = openravepy.openravepy_int.ErrorCode.Failed¶

InconsistentConstraints = openravepy.openravepy_int.ErrorCode.InconsistentConstraints¶

InvalidArguments = openravepy.openravepy_int.ErrorCode.InvalidArguments¶

InvalidInterfaceHash = openravepy.openravepy_int.ErrorCode.InvalidInterfaceHash¶

InvalidPlugin = openravepy.openravepy_int.ErrorCode.InvalidPlugin¶

InvalidState = openravepy.openravepy_int.ErrorCode.InvalidState¶

NotImplemented = openravepy.openravepy_int.ErrorCode.NotImplemented¶

NotInitialized = openravepy.openravepy_int.ErrorCode.NotInitialized¶

Timeout = openravepy.openravepy_int.ErrorCode.Timeout¶

names = {'NotInitialized': openravepy.openravepy_int.ErrorCode.NotInitialized, 'EnvironmentNotLocked': openravepy.openravepy_int.ErrorCode.EnvironmentNotLocked, 'InvalidPlugin': openravepy.openravepy_int.ErrorCode.InvalidPlugin, 'CommandNotSupported': openravepy.openravepy_int.ErrorCode.CommandNotSupported, 'Assert': openravepy.openravepy_int.ErrorCode.Assert, 'Failed': openravepy.openravepy_int.ErrorCode.Failed, 'Timeout': openravepy.openravepy_int.ErrorCode.Timeout, 'InvalidState': openravepy.openravepy_int.ErrorCode.InvalidState, 'InvalidArguments': openravepy.openravepy_int.ErrorCode.InvalidArguments, 'InconsistentConstraints': openravepy.openravepy_int.ErrorCode.InconsistentConstraints, 'InvalidInterfaceHash': openravepy.openravepy_int.ErrorCode.InvalidInterfaceHash, 'NotImplemented': openravepy.openravepy_int.ErrorCode.NotImplemented}¶

values = {0: openravepy.openravepy_int.ErrorCode.Failed, 1: openravepy.openravepy_int.ErrorCode.InvalidArguments, 2: openravepy.openravepy_int.ErrorCode.EnvironmentNotLocked, 3: openravepy.openravepy_int.ErrorCode.CommandNotSupported, 4: openravepy.openravepy_int.ErrorCode.Assert, 5: openravepy.openravepy_int.ErrorCode.InvalidPlugin, 6: openravepy.openravepy_int.ErrorCode.InvalidInterfaceHash, 7: openravepy.openravepy_int.ErrorCode.NotImplemented, 8: openravepy.openravepy_int.ErrorCode.InconsistentConstraints, 9: openravepy.openravepy_int.ErrorCode.NotInitialized, 10: openravepy.openravepy_int.ErrorCode.InvalidState, 11: openravepy.openravepy_int.ErrorCode.Timeout}¶

class openravepy.openravepy_int.GeometryType¶

Bases: Boost.Python.enum

Box = openravepy.openravepy_int.GeometryType.Box¶

Cylinder = openravepy.openravepy_int.GeometryType.Cylinder¶

None = openravepy.openravepy_int.GeometryType.None¶

Sphere = openravepy.openravepy_int.GeometryType.Sphere¶

Trimesh = openravepy.openravepy_int.GeometryType.Trimesh¶

names = {'Box': openravepy.openravepy_int.GeometryType.Box, 'Sphere': openravepy.openravepy_int.GeometryType.Sphere, 'None': openravepy.openravepy_int.GeometryType.None, 'Cylinder': openravepy.openravepy_int.GeometryType.Cylinder, 'Trimesh': openravepy.openravepy_int.GeometryType.Trimesh}¶

values = {0: openravepy.openravepy_int.GeometryType.None, 1: openravepy.openravepy_int.GeometryType.Box, 2: openravepy.openravepy_int.GeometryType.Sphere, 3: openravepy.openravepy_int.GeometryType.Cylinder, 4: openravepy.openravepy_int.GeometryType.Trimesh}¶

class openravepy.openravepy_int.GraphHandle¶

Bases: Boost.Python.instance

Raises an exception This class cannot be instantiated from Python

Close((GraphHandle)arg1) → None¶

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

void SetShow(bool bshow)

Shows or hides the plot without destroying its resources.

SetTransform((GraphHandle)arg1, (object)arg2) → None :¶

void SetTransform(const RaveTransform < float > & t)

Changes the underlying transformation of the plot.

Parameters

t -

new transformation of the plot

class openravepy.openravepy_int.IkFilterOptions¶

Bases: Boost.Python.enum

IkFilterOptions

Controls what information gets validated when searching for an inverse kinematics solution.

CheckEnvCollisions = openravepy.openravepy_int.IkFilterOptions.CheckEnvCollisions¶

IgnoreCustomFilters = openravepy.openravepy_int.IkFilterOptions.IgnoreCustomFilters¶

IgnoreEndEffectorCollisions = openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorCollisions¶

IgnoreEndEffectorEnvCollisions = openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorEnvCollisions¶

IgnoreEndEffectorSelfCollisions = openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorSelfCollisions¶

IgnoreJointLimits = openravepy.openravepy_int.IkFilterOptions.IgnoreJointLimits¶

IgnoreSelfCollisions = openravepy.openravepy_int.IkFilterOptions.IgnoreSelfCollisions¶

names = {'IgnoreEndEffectorCollisions': openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorCollisions, 'IgnoreCustomFilters': openravepy.openravepy_int.IkFilterOptions.IgnoreCustomFilters, 'IgnoreSelfCollisions': openravepy.openravepy_int.IkFilterOptions.IgnoreSelfCollisions, 'IgnoreEndEffectorEnvCollisions': openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorEnvCollisions, 'CheckEnvCollisions': openravepy.openravepy_int.IkFilterOptions.CheckEnvCollisions, 'IgnoreEndEffectorSelfCollisions': openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorSelfCollisions, 'IgnoreJointLimits': openravepy.openravepy_int.IkFilterOptions.IgnoreJointLimits}¶

values = {32: openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorSelfCollisions, 1: openravepy.openravepy_int.IkFilterOptions.CheckEnvCollisions, 2: openravepy.openravepy_int.IkFilterOptions.IgnoreSelfCollisions, 4: openravepy.openravepy_int.IkFilterOptions.IgnoreJointLimits, 8: openravepy.openravepy_int.IkFilterOptions.IgnoreCustomFilters, 16: openravepy.openravepy_int.IkFilterOptions.IgnoreEndEffectorEnvCollisions}¶

class openravepy.openravepy_int.IkParameterization¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

__init__( (object)arg1, (object)primitive, (IkParameterizationType)type) -> None

__init__( (object)arg1, (str)str) -> None

__init__( (object)arg1, (IkParameterization)ikparam) -> None

ClearCustomValues((IkParameterization)arg1[, (str)name]) → int :¶

size_t ClearCustomValues(const std::string & name = std::string() )

clears custom data

Parameters

name -

if name is empty, will clear all the data, otherwise will clear only the custom data with that name

Return

number of elements erased

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

dReal ComputeDistanceSqr(const IkParameterization & ikparam)

Computes the distance squared between two IK parmaeterizations.

GetConfigurationSpecification((IkParameterization)arg1) → object :¶

ConfigurationSpecification GetConfigurationSpecification(const std::string & interpolation = “” )

GetConfigurationSpecification( (IkParameterization)arg1, (object)type) -> object :

ConfigurationSpecification GetConfigurationSpecification(const std::string & interpolation = “” )

GetConfigurationSpecificationFromType((IkParameterizationType)type[, (str)interpolation]) → object :¶

ConfigurationSpecification GetConfigurationSpecification(const std::string & interpolation = “” )

GetCustomDataMap((IkParameterization)arg1) → object :¶

const std::map< std::string, std::vector< dReal > > & GetCustomDataMap()

returns a const reference of the custom data key/value pairs

GetCustomValues((IkParameterization)arg1, (str)name) → object :¶

bool GetCustomValues(const std::string & name, std::vector< dReal > & values)

gets custom data if it exists, returns false if it doesn’t

GetDOF((IkParameterization)arg1) → int :¶

int GetDOF()

Returns the minimum degree of freedoms required for the IK type. Does count custom data.

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

int GetDOF()

Returns the minimum degree of freedoms required for the IK type. Does count custom data.

GetDOFFromType((IkParameterizationType)type) → int :¶

int GetDOF()

Returns the minimum degree of freedoms required for the IK type. Does count custom data.

GetDirection3D((IkParameterization)arg1) → object :¶

const Vector & GetDirection3D()

GetLookat3D((IkParameterization)arg1) → object :¶

const Vector & GetLookat3D()

GetNumberOfValues((IkParameterization)arg1) → int :¶

int GetNumberOfValues()

Returns the number of values used to represent the parameterization ( >= dof ). Does count custom data.

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

int GetNumberOfValues()

Returns the number of values used to represent the parameterization ( >= dof ). Does count custom data.

GetNumberOfValuesFromType((IkParameterizationType)type) → int :¶

int GetNumberOfValues()

Returns the number of values used to represent the parameterization ( >= dof ). Does count custom data.

GetRay4D((IkParameterization)arg1) → Ray :¶

const RAY GetRay4D()

GetRotation3D((IkParameterization)arg1) → object :¶

const Vector & GetRotation3D()

GetTransform6D((IkParameterization)arg1) → object :¶

const Transform & GetTransform6D()

GetTranslation3D((IkParameterization)arg1) → object :¶

const Vector & GetTranslation3D()

GetTranslationDirection5D((IkParameterization)arg1) → Ray :¶

const RAY GetTranslationDirection5D()

GetTranslationLocalGlobal6D((IkParameterization)arg1) → object :¶

std::pair< Vector , Vector > GetTranslationLocalGlobal6D()

GetTranslationXAxisAngle4D((IkParameterization)arg1) → object :¶

std::pair< Vector , dReal > GetTranslationXAxisAngle4D()

GetTranslationXAxisAngleZNorm4D((IkParameterization)arg1) → object :¶

std::pair< Vector , dReal > GetTranslationXAxisAngleZNorm4D()

GetTranslationXY2D((IkParameterization)arg1) → object :¶

const Vector & GetTranslationXY2D()

GetTranslationXYOrientation3D((IkParameterization)arg1) → object :¶

const Vector & GetTranslationXYOrientation3D()

GetTranslationYAxisAngle4D((IkParameterization)arg1) → object :¶

std::pair< Vector , dReal > GetTranslationYAxisAngle4D()

GetTranslationYAxisAngleXNorm4D((IkParameterization)arg1) → object :¶

std::pair< Vector , dReal > GetTranslationYAxisAngleXNorm4D()

GetTranslationZAxisAngle4D((IkParameterization)arg1) → object :¶

std::pair< Vector , dReal > GetTranslationZAxisAngle4D()

GetTranslationZAxisAngleYNorm4D((IkParameterization)arg1) → object :¶

std::pair< Vector , dReal > GetTranslationZAxisAngleYNorm4D()

GetType((IkParameterization)arg1) → IkParameterizationType :¶

IkParameterizationType GetType()

GetValues((IkParameterization)arg1) → object :¶

void GetValues(std::vector< dReal >::iterator itvalues)

fills the iterator with the serialized values of the ikparameterization.

The container the iterator points to needs to have GetNumberOfValues() available. Does not support custom data Don’t normalize quaternions since it could hold velocity data.

MultiplyTransform((IkParameterization)arg1, (object)arg2) → None :¶

IkParameterization & MultiplyTransform(const Transform & t)

in-place left-transform into a new coordinate system. Equivalent to t * ikparam

SetCustomValue((IkParameterization)arg1, (str)name, (float)value) → None :¶

void SetCustomValue(const std::string & name, dReal value)

sets named custom data in the ik parameterization (

See

SetCustomValues)

SetCustomValues((IkParameterization)arg1, (str)name, (object)values) → None :¶

void SetCustomValues(const std::string & name, const std::vector< dReal > & values)

sets named custom data in the ik parameterization

The custom data is serialized along with the rest of the parameters and can also be part of a configuration specification under the “ikparam_values” anotation. The custom data name can have meta-tags for the type of transformation the data undergos when MultiplyTransform is called. For example, if the user wants to have an extra 3 values that represent “direction”, then the direction has to be rotated along with all the data or coordinate systems can get lost. The anotations are specified by putting: somewhere in the string. The s can be: , , , If , the first value is expected to be the unique id of the ik type (GetType()&IKP_UniqueIdMask). The other values can be computed from IkParameterization::GetValuesParameters

name -

Describes the type of data, cannot contain spaces or new lines.

values -

the values representing the data Exceptions

openrave_exception -

throws if the name is invalid

SetDirection3D((IkParameterization)arg1, (object)dir) → None :¶

void SetDirection3D(const Vector & dir)

SetLookat3D((IkParameterization)arg1, (object)pos) → None :¶

void SetLookat3D(const Vector & trans)

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

void SetRay4D(const RAY & ray)

SetRotation3D((IkParameterization)arg1, (object)quat) → None :¶

void SetRotation3D(const Vector & quaternion)

SetTransform6D((IkParameterization)arg1, (object)transform) → None :¶

void SetTransform6D(const Transform & t)

SetTranslation3D((IkParameterization)arg1, (object)pos) → None :¶

void SetTranslation3D(const Vector & trans)

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

void SetTranslationDirection5D(const RAY & ray)

SetTranslationLocalGlobal6D((IkParameterization)arg1, (object)localpos, (object)pos) → None :¶

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

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

void SetTranslationXAxisAngle4D(const Vector & trans, dReal angle)

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

void SetTranslationXAxisAngleZNorm4D(const Vector & trans, dReal angle)

SetTranslationXY2D((IkParameterization)arg1, (object)pos) → None :¶

void SetTranslationXY2D(const Vector & trans)

SetTranslationXYOrientation3D((IkParameterization)arg1, (object)posangle) → None :¶

void SetTranslationXYOrientation3D(const Vector & trans)

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

void SetTranslationYAxisAngle4D(const Vector & trans, dReal angle)

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

void SetTranslationYAxisAngleXNorm4D(const Vector & trans, dReal angle)

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

void SetTranslationZAxisAngle4D(const Vector & trans, dReal angle)

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

void SetTranslationZAxisAngleYNorm4D(const Vector & trans, dReal angle)

SetValues((IkParameterization)arg1, (object)values, (IkParameterizationType)type) → None :¶

void SetValues(std::vector< dReal >::const_iterator itvalues, IkParameterizationType iktype)

sets a serialized set of values for the IkParameterization

Function does not handle custom data. Don’t normalize quaternions since it could hold velocity data.

Transform((IkParameterization)arg1, (object)arg2) → object :¶

Returns a new parameterization with transformed by the transformation T (T * ik)

Type¶

alias of IkParameterizationType

class openravepy.openravepy_int.IkParameterizationType¶

Bases: Boost.Python.enum

IkParameterizationType

The types of inverse kinematics parameterizations supported.

The minimum degree of freedoms required is set in the upper 4 bits of each type. The number of values used to represent the parameterization ( >= dof ) is the next 4 bits. The lower bits contain a unique id of the type.

CustomDataBit = openravepy.openravepy_int.IkParameterizationType.CustomDataBit¶

Direction3D = openravepy.openravepy_int.IkParameterizationType.Direction3D¶

Direction3DVelocity = openravepy.openravepy_int.IkParameterizationType.Direction3DVelocity¶

Lookat3D = openravepy.openravepy_int.IkParameterizationType.Lookat3D¶

Lookat3DVelocity = openravepy.openravepy_int.IkParameterizationType.Lookat3DVelocity¶

Ray4D = openravepy.openravepy_int.IkParameterizationType.Ray4D¶

Ray4DVelocity = openravepy.openravepy_int.IkParameterizationType.Ray4DVelocity¶

Rotation3D = openravepy.openravepy_int.IkParameterizationType.Rotation3D¶

Rotation3DVelocity = openravepy.openravepy_int.IkParameterizationType.Rotation3DVelocity¶

Transform6D = openravepy.openravepy_int.IkParameterizationType.Transform6D¶

Transform6DVelocity = openravepy.openravepy_int.IkParameterizationType.Transform6DVelocity¶

Translation3D = openravepy.openravepy_int.IkParameterizationType.Translation3D¶

Translation3DVelocity = openravepy.openravepy_int.IkParameterizationType.Translation3DVelocity¶

TranslationDirection5D = openravepy.openravepy_int.IkParameterizationType.TranslationDirection5D¶

TranslationDirection5DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationDirection5DVelocity¶

TranslationLocalGlobal6D = openravepy.openravepy_int.IkParameterizationType.TranslationLocalGlobal6D¶

TranslationLocalGlobal6DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationLocalGlobal6DVelocity¶

TranslationXAxisAngle4D = openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngle4D¶

TranslationXAxisAngle4DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngle4DVelocity¶

TranslationXAxisAngleZNorm4D = openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngleZNorm4D¶

TranslationXAxisAngleZNorm4DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngleZNorm4DVelocity¶

TranslationXY2D = openravepy.openravepy_int.IkParameterizationType.TranslationXY2D¶

TranslationXY2DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationXY2DVelocity¶

TranslationXYOrientation3D = openravepy.openravepy_int.IkParameterizationType.TranslationXYOrientation3D¶

TranslationXYOrientation3DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationXYOrientation3DVelocity¶

TranslationYAxisAngle4D = openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngle4D¶

TranslationYAxisAngle4DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngle4DVelocity¶

TranslationYAxisAngleXNorm4D = openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngleXNorm4D¶

TranslationYAxisAngleXNorm4DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngleXNorm4DVelocity¶

TranslationZAxisAngle4D = openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngle4D¶

TranslationZAxisAngle4DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngle4DVelocity¶

TranslationZAxisAngleYNorm4D = openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngleYNorm4D¶

TranslationZAxisAngleYNorm4DVelocity = openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngleYNorm4DVelocity¶

UniqueIdMask = openravepy.openravepy_int.IkParameterizationType.UniqueIdMask¶

VelocityDataBit = openravepy.openravepy_int.IkParameterizationType.VelocityDataBit¶

names = {'Rotation3DVelocity': openravepy.openravepy_int.IkParameterizationType.Rotation3DVelocity, 'Ray4D': openravepy.openravepy_int.IkParameterizationType.Ray4D, 'TranslationXY2D': openravepy.openravepy_int.IkParameterizationType.TranslationXY2D, 'TranslationXAxisAngleZNorm4D': openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngleZNorm4D, 'TranslationXYOrientation3D': openravepy.openravepy_int.IkParameterizationType.TranslationXYOrientation3D, 'TranslationXY2DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationXY2DVelocity, 'TranslationYAxisAngleXNorm4D': openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngleXNorm4D, 'Translation3DVelocity': openravepy.openravepy_int.IkParameterizationType.Translation3DVelocity, 'Direction3D': openravepy.openravepy_int.IkParameterizationType.Direction3D, 'TranslationZAxisAngleYNorm4D': openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngleYNorm4D, 'VelocityDataBit': openravepy.openravepy_int.IkParameterizationType.VelocityDataBit, 'Lookat3DVelocity': openravepy.openravepy_int.IkParameterizationType.Lookat3DVelocity, 'Direction3DVelocity': openravepy.openravepy_int.IkParameterizationType.Direction3DVelocity, 'CustomDataBit': openravepy.openravepy_int.IkParameterizationType.CustomDataBit, 'TranslationYAxisAngle4DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngle4DVelocity, 'TranslationYAxisAngle4D': openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngle4D, 'Transform6DVelocity': openravepy.openravepy_int.IkParameterizationType.Transform6DVelocity, 'TranslationYAxisAngleXNorm4DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngleXNorm4DVelocity, 'TranslationDirection5DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationDirection5DVelocity, 'Lookat3D': openravepy.openravepy_int.IkParameterizationType.Lookat3D, 'TranslationXAxisAngleZNorm4DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngleZNorm4DVelocity, 'Rotation3D': openravepy.openravepy_int.IkParameterizationType.Rotation3D, 'TranslationDirection5D': openravepy.openravepy_int.IkParameterizationType.TranslationDirection5D, 'Ray4DVelocity': openravepy.openravepy_int.IkParameterizationType.Ray4DVelocity, 'Transform6D': openravepy.openravepy_int.IkParameterizationType.Transform6D, 'TranslationXYOrientation3DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationXYOrientation3DVelocity, 'TranslationXAxisAngle4D': openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngle4D, 'TranslationZAxisAngle4D': openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngle4D, 'Translation3D': openravepy.openravepy_int.IkParameterizationType.Translation3D, 'TranslationZAxisAngle4DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngle4DVelocity, 'TranslationXAxisAngle4DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngle4DVelocity, 'TranslationZAxisAngleYNorm4DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngleYNorm4DVelocity, 'TranslationLocalGlobal6DVelocity': openravepy.openravepy_int.IkParameterizationType.TranslationLocalGlobal6DVelocity, 'UniqueIdMask': openravepy.openravepy_int.IkParameterizationType.UniqueIdMask, 'TranslationLocalGlobal6D': openravepy.openravepy_int.IkParameterizationType.TranslationLocalGlobal6D}¶

values = {32768: openravepy.openravepy_int.IkParameterizationType.VelocityDataBit, 1728053249: openravepy.openravepy_int.IkParameterizationType.Transform6D, 872415234: openravepy.openravepy_int.IkParameterizationType.Rotation3D, 855638019: openravepy.openravepy_int.IkParameterizationType.Translation3D, 587202564: openravepy.openravepy_int.IkParameterizationType.Direction3D, 1174405125: openravepy.openravepy_int.IkParameterizationType.Ray4D, 587202566: openravepy.openravepy_int.IkParameterizationType.Lookat3D, 1442840583: openravepy.openravepy_int.IkParameterizationType.TranslationDirection5D, 570425352: openravepy.openravepy_int.IkParameterizationType.TranslationXY2D, 855638025: openravepy.openravepy_int.IkParameterizationType.TranslationXYOrientation3D, 905969674: openravepy.openravepy_int.IkParameterizationType.TranslationLocalGlobal6D, 1140850699: openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngle4D, 1140850700: openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngle4D, 1140850701: openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngle4D, 1140850702: openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngleZNorm4D, 1140850703: openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngleXNorm4D, 1140850704: openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngleYNorm4D, 855670787: openravepy.openravepy_int.IkParameterizationType.Translation3DVelocity, 587235332: openravepy.openravepy_int.IkParameterizationType.Direction3DVelocity, 1174437893: openravepy.openravepy_int.IkParameterizationType.Ray4DVelocity, 1728086017: openravepy.openravepy_int.IkParameterizationType.Transform6DVelocity, 587235334: openravepy.openravepy_int.IkParameterizationType.Lookat3DVelocity, 1442873351: openravepy.openravepy_int.IkParameterizationType.TranslationDirection5DVelocity, 570458120: openravepy.openravepy_int.IkParameterizationType.TranslationXY2DVelocity, 855670793: openravepy.openravepy_int.IkParameterizationType.TranslationXYOrientation3DVelocity, 906002442: openravepy.openravepy_int.IkParameterizationType.TranslationLocalGlobal6DVelocity, 872448002: openravepy.openravepy_int.IkParameterizationType.Rotation3DVelocity, 1140883467: openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngle4DVelocity, 1140883468: openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngle4DVelocity, 1140883469: openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngle4DVelocity, 1140883470: openravepy.openravepy_int.IkParameterizationType.TranslationXAxisAngleZNorm4DVelocity, 1140883471: openravepy.openravepy_int.IkParameterizationType.TranslationYAxisAngleXNorm4DVelocity, 65536: openravepy.openravepy_int.IkParameterizationType.CustomDataBit, 1140883472: openravepy.openravepy_int.IkParameterizationType.TranslationZAxisAngleYNorm4DVelocity, 65535: openravepy.openravepy_int.IkParameterizationType.UniqueIdMask}¶

class openravepy.openravepy_int.IkReturn¶

Bases: Boost.Python.instance

__init__( (object)arg1, (IkReturnAction)action) -> None

GetAction((IkReturn)arg1) → IkReturnAction :¶

Retuns IkReturn::_action

GetMapData((IkReturn)arg1, (str)key) → object :¶

Indexes into the map and returns an array of numbers. If key doesn’t exist, returns None

GetMapDataDict((IkReturn)arg1) → object :¶

Returns a dictionary copy for IkReturn::_mapdata

GetSolution((IkReturn)arg1) → object :¶

Retuns IkReturn::_vsolution

GetUserData((IkReturn)arg1) → object :¶

Retuns IkReturn::_userdata

SetMapKeyValue((IkReturn)arg1, (str)arg2, (object)key, value) → None :¶

Adds key/value pair to IKReturn::_mapdata

SetSolution((IkReturn)arg1, (object)solution) → None :¶

Set IKReturn::_vsolution

SetUserData((IkReturn)arg1, (UserData)data) → None :¶

Set IKReturn::_userdata

class openravepy.openravepy_int.IkReturnAction¶

Bases: Boost.Python.enum

IkReturnAction

Return value for the ik filter that can be optionally set on an ik solver.

Quit = openravepy.openravepy_int.IkReturnAction.Quit¶

QuitEndEffectorCollision = openravepy.openravepy_int.IkReturnAction.QuitEndEffectorCollision¶

Reject = openravepy.openravepy_int.IkReturnAction.Reject¶

RejectCustomFilter = openravepy.openravepy_int.IkReturnAction.RejectCustomFilter¶

RejectEnvCollision = openravepy.openravepy_int.IkReturnAction.RejectEnvCollision¶

RejectJointLimits = openravepy.openravepy_int.IkReturnAction.RejectJointLimits¶

RejectKinematics = openravepy.openravepy_int.IkReturnAction.RejectKinematics¶

RejectKinematicsPrecision = openravepy.openravepy_int.IkReturnAction.RejectKinematicsPrecision¶

RejectSelfCollision = openravepy.openravepy_int.IkReturnAction.RejectSelfCollision¶

Success = openravepy.openravepy_int.IkReturnAction.Success¶

names = {'Quit': openravepy.openravepy_int.IkReturnAction.Quit, 'RejectCustomFilter': openravepy.openravepy_int.IkReturnAction.RejectCustomFilter, 'Success': openravepy.openravepy_int.IkReturnAction.Success, 'Reject': openravepy.openravepy_int.IkReturnAction.Reject, 'QuitEndEffectorCollision': openravepy.openravepy_int.IkReturnAction.QuitEndEffectorCollision, 'RejectSelfCollision': openravepy.openravepy_int.IkReturnAction.RejectSelfCollision, 'RejectEnvCollision': openravepy.openravepy_int.IkReturnAction.RejectEnvCollision, 'RejectKinematicsPrecision': openravepy.openravepy_int.IkReturnAction.RejectKinematicsPrecision, 'RejectJointLimits': openravepy.openravepy_int.IkReturnAction.RejectJointLimits, 'RejectKinematics': openravepy.openravepy_int.IkReturnAction.RejectKinematics}¶

values = {0: openravepy.openravepy_int.IkReturnAction.Success, 1: openravepy.openravepy_int.IkReturnAction.Reject, 2: openravepy.openravepy_int.IkReturnAction.Quit, 32769: openravepy.openravepy_int.IkReturnAction.RejectCustomFilter, 65: openravepy.openravepy_int.IkReturnAction.RejectEnvCollision, 33: openravepy.openravepy_int.IkReturnAction.RejectSelfCollision, 257: openravepy.openravepy_int.IkReturnAction.RejectJointLimits, 130: openravepy.openravepy_int.IkReturnAction.QuitEndEffectorCollision, 17: openravepy.openravepy_int.IkReturnAction.RejectKinematics, 513: openravepy.openravepy_int.IkReturnAction.RejectKinematicsPrecision}¶

class openravepy.openravepy_int.IkSolver¶

Bases: openravepy.openravepy_int.Interface

Raises an exception This class cannot be instantiated from Python

GetFreeParameters((IkSolver)arg1) → object :¶

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

gets the free parameters from the current robot configuration

Parameters

vFreeParameters -

is filled with GetNumFreeParameters() parameters in [0,1] range

Return

true if succeeded

GetNumFreeParameters((IkSolver)arg1) → int :¶

int GetNumFreeParameters()

Number of free parameters defining the null solution space.

Each parameter is always in the range of [0,1].

RegisterCustomFilter((IkSolver)arg1, (int)priority, (object)callback) → object :¶

UserDataPtr RegisterCustomFilter(int priority, const IkFilterCallbackFn & filterfn)

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

Parameters

priority -

• The priority of the filter that controls the order in which filters get called. Higher priority filters get called first. If not certain what to set, use 0.

filterfn -

• an optional filter function to be called, see IkFilterCallbackFn. Multiple filters can be set at once, each filter will be called according to its priority; higher values get called first. The default implementation of IkSolverBase manages the filters internally. Users implementing their own IkSolverBase should call _CallFilters to run the internally managed filters.

Return

a managed handle to the filter. If this handle is released, then the fitler will be removed. Release operation is .

Solve((IkSolver)arg1, (object)ikparam, (object)q0, (int)filteroptions) → IkReturn¶

Solve( (IkSolver)arg1, (object)ikparam, (object)q0, (object)freeparameters, (int)filteroptions) -> IkReturn

SolveAll((IkSolver)arg1, (object)ikparam, (int)filteroptions) → object¶

SolveAll( (IkSolver)arg1, (object)ikparam, (object)freeparameters, (int)filteroptions) -> object

Supports((IkSolver)arg1, (IkParameterizationType)iktype) → bool :¶

bool Supports(IkParameterizationType iktype)

returns true if the solver supports a particular ik parameterization as input.

class openravepy.openravepy_int.Interface¶

Bases: Boost.Python.instance

Raises an exception This class cannot be instantiated from Python

Clone((Interface)arg1, (Interface)ref, (int)cloningoptions) → None :¶

void Clone(InterfaceBaseConstPtr preference, int cloningoptions)

Clone the contents of an interface to the current interface.

Parameters

preference -

the interface whose information to clone

cloningoptions -

mask of CloningOptions Exceptions

openrave_exception -

if command doesn’t succeed

GetDescription((Interface)arg1) → object :¶

const std::string & GetDescription()

Documentation of the interface in reStructuredText format. See Documenting Interfaces.

GetEnv((Interface)arg1) → Environment :¶

EnvironmentBasePtr GetEnv()

Return

the environment that this interface is attached to

GetInterfaceType((Interface)arg1) → InterfaceType :¶

InterfaceType GetInterfaceType()

GetPluginName((Interface)arg1) → str :¶

const std::string & GetPluginName()

set internally by RaveDatabase

Return

the pluginname this interface was loaded from

GetReadableInterface((Interface)arg1, (str)arg2) → object¶

GetReadableInterfaces((Interface)arg1) → object :¶

const READERSMAP & GetReadableInterfaces()

GetUserData((Interface)arg1[, (str)key]) → object :¶

UserDataPtr GetUserData()

return the user custom data

GetXMLId((Interface)arg1) → str :¶

const std::string & GetXMLId()

set internally by RaveDatabase

Return

the unique identifier that describes this class type, case is ignored should be the same id used to create the object

RemoveUserData((Interface)arg1, (str)arg2) → bool¶

SendCommand((Interface)arg1, (str)cmd[, (bool)releasegil]) → object :¶

bool SendCommand(std::ostream & os, std::istream & is)

Used to send special commands to the interface and receive output.

The command must be registered by RegisterCommand. A special command ‘ is always supported and provides a way for the user to query the current commands and the help string. The format of the returned help commands are in reStructuredText. The following commands are possible: Parameters

is -

the input stream containing the command

os -

the output stream containing the output Exceptions

openrave_exception -

Throw if the command is not supported.

Return

true if the command is successfully processed, otherwise false. The calling conventions between C++ and Python differ a little.

In C++ the syntax is:

success = SendCommand(OUT, IN)

In python, the syntax is:

OUT = SendCommand(IN,releasegil)
success = OUT is not None

The releasegil parameter controls whether the python Global Interpreter Lock should be released when executing this code. For calls that take a long time and if there are many threads running called from different python threads, releasing the GIL could speed up things a lot. Please keep in mind that releasing and re-acquiring the GIL also takes computation time.

SetDescription((Interface)arg1, (str)arg2) → None :¶

void SetDescription(const std::string & description)

SetReadableInterface((Interface)arg1, (str)xmltag, (object)xmlreadable) → None :¶

XMLReadablePtr SetReadableInterface(const std::string & xmltag, XMLReadablePtr readable)

set a new readable interface and return the previously set interface if it exists

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

void SetUserData(UserDataPtr data)

set user data

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

void SetUserData(UserDataPtr data)

set user data

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

void SetUserData(UserDataPtr data)

set user data

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

void SetUserData(UserDataPtr data)

set user data

class openravepy.openravepy_int.InterfaceBase¶

Bases: Boost.Python.instance

Raises an exception This class cannot be instantiated from Python

class openravepy.openravepy_int.InterfaceType¶

Bases: Boost.Python.enum

collisionchecker = openravepy.openravepy_int.InterfaceType.collisionchecker¶

controller = openravepy.openravepy_int.InterfaceType.controller¶

iksolver = openravepy.openravepy_int.InterfaceType.iksolver¶

kinbody = openravepy.openravepy_int.InterfaceType.kinbody¶

module = openravepy.openravepy_int.InterfaceType.module¶

names = {'planner': openravepy.openravepy_int.InterfaceType.planner, 'kinbody': openravepy.openravepy_int.InterfaceType.kinbody, 'physicsengine': openravepy.openravepy_int.InterfaceType.physicsengine, 'sensorsystem': openravepy.openravepy_int.InterfaceType.sensorsystem, 'spacesampler': openravepy.openravepy_int.InterfaceType.spacesampler, 'robot': openravepy.openravepy_int.InterfaceType.robot, 'module': openravepy.openravepy_int.InterfaceType.module, 'collisionchecker': openravepy.openravepy_int.InterfaceType.collisionchecker, 'viewer': openravepy.openravepy_int.InterfaceType.viewer, 'controller': openravepy.openravepy_int.InterfaceType.controller, 'probleminstance': openravepy.openravepy_int.InterfaceType.probleminstance, 'trajectory': openravepy.openravepy_int.InterfaceType.trajectory, 'iksolver': openravepy.openravepy_int.InterfaceType.iksolver, 'sensor': openravepy.openravepy_int.InterfaceType.sensor}¶

physicsengine = openravepy.openravepy_int.InterfaceType.physicsengine¶

planner = openravepy.openravepy_int.InterfaceType.planner¶

probleminstance = openravepy.openravepy_int.InterfaceType.probleminstance¶

robot = openravepy.openravepy_int.InterfaceType.robot¶

sensor = openravepy.openravepy_int.InterfaceType.sensor¶

sensorsystem = openravepy.openravepy_int.InterfaceType.sensorsystem¶

spacesampler = openravepy.openravepy_int.InterfaceType.spacesampler¶

trajectory = openravepy.openravepy_int.InterfaceType.trajectory¶

values = {1: openravepy.openravepy_int.InterfaceType.planner, 2: openravepy.openravepy_int.InterfaceType.robot, 3: openravepy.openravepy_int.InterfaceType.sensorsystem, 4: openravepy.openravepy_int.InterfaceType.controller, 5: openravepy.openravepy_int.InterfaceType.module, 6: openravepy.openravepy_int.InterfaceType.iksolver, 7: openravepy.openravepy_int.InterfaceType.kinbody, 8: openravepy.openravepy_int.InterfaceType.physicsengine, 9: openravepy.openravepy_int.InterfaceType.sensor, 10: openravepy.openravepy_int.InterfaceType.collisionchecker, 11: openravepy.openravepy_int.InterfaceType.trajectory, 12: openravepy.openravepy_int.InterfaceType.viewer, 13: openravepy.openravepy_int.InterfaceType.spacesampler}¶

viewer = openravepy.openravepy_int.InterfaceType.viewer¶

class openravepy.openravepy_int.Interval¶

Bases: Boost.Python.enum

IntervalType

Specifies the boundary conditions of intervals for sampling.

Closed = openravepy.openravepy_int.Interval.Closed¶

Open = openravepy.openravepy_int.Interval.Open¶

OpenEnd = openravepy.openravepy_int.Interval.OpenEnd¶

OpenStart = openravepy.openravepy_int.Interval.OpenStart¶

names = {'OpenEnd': openravepy.openravepy_int.Interval.OpenEnd, 'Open': openravepy.openravepy_int.Interval.Open, 'OpenStart': openravepy.openravepy_int.Interval.OpenStart, 'Closed': openravepy.openravepy_int.Interval.Closed}¶

values = {0: openravepy.openravepy_int.Interval.Open, 1: openravepy.openravepy_int.Interval.OpenStart, 2: openravepy.openravepy_int.Interval.OpenEnd, 3: openravepy.openravepy_int.Interval.Closed}¶

class openravepy.openravepy_int.KinBody¶

Bases: openravepy.openravepy_int.Interface

Raises an exception This class cannot be instantiated from Python

class AdjacentOptions¶

Bases: Boost.Python.enum

AdjacentOptions

specifies the type of adjacent link information to receive

ActiveDOFs = openravepy.openravepy_int.AdjacentOptions.ActiveDOFs¶

Enabled = openravepy.openravepy_int.AdjacentOptions.Enabled¶

names = {'ActiveDOFs': openravepy.openravepy_int.AdjacentOptions.ActiveDOFs, 'Enabled': openravepy.openravepy_int.AdjacentOptions.Enabled}¶

values = {1: openravepy.openravepy_int.AdjacentOptions.Enabled, 2: openravepy.openravepy_int.AdjacentOptions.ActiveDOFs}¶

KinBody.CalculateAngularVelocityJacobian((KinBody)arg1, (int)linkindex) → object :¶

void CalculateAngularVelocityJacobian(int linkindex, std::vector< dReal > & jacobian)

Computes the angular velocity jacobian of a specified link about the axes of world coordinates.

KinBody.CalculateJacobian((KinBody)arg1, (int)linkindex, (object)position) → object :¶

void CalculateJacobian(int linkindex, const Vector & position, std::vector< dReal > & jacobian)

calls std::vector version of ComputeJacobian internally

KinBody.CalculateRotationJacobian((KinBody)arg1, (int)linkindex, (object)quat) → object :¶

void CalculateRotationJacobian(int linkindex, const Vector & quat, std::vector< dReal > & jacobian)

Computes the rotational jacobian as a quaternion with respect to an initial rotation.

Parameters

linkindex -

of the link that the rotation is attached to

qInitialRot -

the rotation in world space whose derivative to take from.

jacobian -

4xDOF matrix

class KinBody.CheckLimitsAction¶

Bases: Boost.Python.enum

CheckLimitsAction

used for specifying the type of limit checking and the messages associated with it

CheckLimits = openravepy.openravepy_int.CheckLimitsAction.CheckLimits¶

CheckLimitsSilent = openravepy.openravepy_int.CheckLimitsAction.CheckLimitsSilent¶

CheckLimitsThrow = openravepy.openravepy_int.CheckLimitsAction.CheckLimitsThrow¶

Nothing = openravepy.openravepy_int.CheckLimitsAction.Nothing¶

names = {'Nothing': openravepy.openravepy_int.CheckLimitsAction.Nothing, 'CheckLimitsThrow': openravepy.openravepy_int.CheckLimitsAction.CheckLimitsThrow, 'CheckLimitsSilent': openravepy.openravepy_int.CheckLimitsAction.CheckLimitsSilent, 'CheckLimits': openravepy.openravepy_int.CheckLimitsAction.CheckLimits}¶

values = {0: openravepy.openravepy_int.CheckLimitsAction.Nothing, 1: openravepy.openravepy_int.CheckLimitsAction.CheckLimits, 2: openravepy.openravepy_int.CheckLimitsAction.CheckLimitsSilent, 3: openravepy.openravepy_int.CheckLimitsAction.CheckLimitsThrow}¶

KinBody.CheckSelfCollision((KinBody)arg1) → bool :¶

bool CheckSelfCollision(CollisionReportPtr report = CollisionReportPtr () )

Check if body is self colliding. Links that are joined together are ignored.

CheckSelfCollision( (KinBody)arg1, (CollisionReport)report) -> bool :

bool CheckSelfCollision(CollisionReportPtr report = CollisionReportPtr () )

Check if body is self colliding. Links that are joined together are ignored.

KinBody.ComputeAABB((KinBody)arg1) → object :¶

AABB ComputeAABB()

Return an axis-aligned bounding box of the entire object in the world coordinate system.

KinBody.ComputeHessianAxisAngle((KinBody)arg1, (int)linkindex[, (object)indices]) → object :¶

void ComputeHessianAxisAngle(int linkindex, std::vector< dReal > & hessian, const std::vector< int > & dofindices = std::vector< int >() )

Computes the DOFx3xDOF hessian of the rotation represented as angle-axis.

Parameters

linkindex -

of the link that defines the frame the position is attached to /

hessian -

DOFx3xDOF matrix such that numpy.dot(dq,numpy.dot(hessian,dq)) is the expected second-order delta angle-axis /

dofindices -

the dof indices to compute the hessian for. If empty, will compute for all the dofs /

KinBody.ComputeHessianTranslation((KinBody)arg1, (int)linkindex, (object)position[, (object)indices]) → object :¶

void ComputeHessianTranslation(int linkindex, const Vector & position, std::vector< dReal > & hessian, const std::vector< int > & dofindices = std::vector< int >() )

Computes the DOFx3xDOF hessian of the linear translation.

Parameters

linkindex -

of the link that defines the frame the position is attached to /

position -

position in world space where to compute derivatives from. /

hessian -

DOFx3xDOF matrix such that numpy.dot(dq,numpy.dot(hessian,dq)) is the expected second-order delta translation /

dofindices -

the dof indices to compute the hessian for. If empty, will compute for all the dofs /

KinBody.ComputeInverseDynamics((KinBody)arg1, (object)dofaccelerations[, (object)externalforcetorque[, (bool)returncomponents]]) → object :¶

Parameters:	returncomponents – If True will return three N-element arrays that represents the torque contributions to M, C, and G. externalforcetorque – A dictionary of link indices and a 6-element array of forces/torques in that order.

KinBody.ComputeJacobianAxisAngle((KinBody)arg1, (int)linkindex[, (object)indices]) → object :¶

void ComputeJacobianAxisAngle(int linkindex, std::vector< dReal > & jacobian, const std::vector< int > & dofindices = std::vector< int >() )

Computes the angular velocity jacobian of a specified link about the axes of world coordinates.

Parameters

linkindex -

of the link that the rotation is attached to

vjacobian -

3xDOF matrix

KinBody.ComputeJacobianTranslation((KinBody)arg1, (int)linkindex, (object)position[, (object)indices]) → object :¶

void ComputeJacobianTranslation(int linkindex, const Vector & position, std::vector< dReal > & jacobian, const std::vector< int > & dofindices = std::vector< int >() )

Computes the translation jacobian with respect to a world position.

Parameters

linkindex -

of the link that defines the frame the position is attached to

position -

position in world space where to compute derivatives from.

jacobian -

3xDOF matrix

dofindices -

the dof indices to compute the jacobian for. If empty, will compute for all the dofs Gets the jacobian with respect to a link by computing the partial differentials for all joints that in the path from the root node to GetLinks()[index] (doesn’t touch the rest of the values)

KinBody.CreateKinBodyStateSaver((KinBody)arg1[, (object)options]) → StateRestoreContext :¶

Creates an object that can be entered using ‘with’ and returns a KinBodyStateSaver

KinBody.DoesAffect((KinBody)arg1, (int)jointindex, (int)linkindex) → int :¶

int8_t DoesAffect(int jointindex, int linkindex)

Returns a nonzero value if the joint effects the link transformation.

Parameters

jointindex -

index of the joint

linkindex -

index of the link In closed loops, all joints on all paths to the root link are counted as affecting the link. If a mimic joint affects the link, then all the joints used in the mimic joint’s computation affect the link. If negative, the partial derivative of the Jacobian should be negated.

KinBody.Enable((KinBody)arg1, (bool)enable) → None :¶

void Enable(bool enable)

Enables or disables all the links.

class KinBody.GeometryInfo¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

KinBody.GetAdjacentLinks((KinBody)arg1) → object :¶

const std::set< int > & GetAdjacentLinks()

return all possible link pairs whose collisions are ignored.

KinBody.GetAttached((KinBody)arg1) → object :¶

void GetAttached(std::set< KinBodyPtr > & setAttached)

Recursively get all attached bodies of this body, including this body.

Parameters

setAttached -

fills with the attached bodies. If any bodies are already in setAttached, then ignores recursing on their attached bodies.

KinBody.GetBodyTransformations((KinBody)arg1, (bool)arg2) → object :¶

void GetLinkTransformations(std::vector< Transform > & transforms)

get the transformations of all the links at once

KinBody.GetChain((KinBody)arg1, (int)linkindex1, (int)linkindex2[, (bool)returnjoints]) → object :¶

bool GetChain(int linkindex1, int linkindex2, std::vector< JointPtr > & vjoints)

2つのリンクを繋ぐ関節の最短経路を計算する．

Parameters

linkindex1 -

始点リンクインデックス

linkindex2 -

終点リンクインデックス

vjoints　関節の経路 -

受動的な関節は，位置関係が固定されているリンクを見つけるために調べられている 受動的な関節も返される可能があるから，注意する必要があります．

Return

経路が存在している場合，trueを返す． If returnjoints is false will return a list of links, otherwise will return a list of links (default is true)

KinBody.GetClosedLoops((KinBody)arg1) → object :¶

const std::vector< std::vector< std::pair< LinkPtr , JointPtr > > > & GetClosedLoops()

Return the set of unique closed loops of the kinematics hierarchy.

Each loop is a set of link indices and joint indices. For example, a loop of link indices: [l_0,l_1,l_2] will consist of three joints connecting l_0 to l_1, l_1 to l_2, and l_2 to l_0. The first element in the pair is the link l_X, the second element in the joint connecting l_X to l_(X+1).

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

UserDataPtr GetCollisionData()

SetCollisionData.

KinBody.GetConfigurationSpecification((KinBody)arg1[, (str)interpolation]) → object :¶

ConfigurationSpecification GetConfigurationSpecification(const std::string & interpolation = “” )

return the configuration specification of the joint values and transform

Note that the return type is by-value, so should not be used in iteration

KinBody.GetConfigurationSpecificationIndices((KinBody)arg1, (object)indices[, (str)interpolation]) → object :¶

ConfigurationSpecification GetConfigurationSpecificationIndices(const std::vector< int > & indices, const std::string & interpolation = “” )

return the configuration specification of the specified joint indices.

Note that the return type is by-value, so should not be used in iteration

KinBody.GetConfigurationValues((KinBody)arg1) → object :¶

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

returns the configuration values as specified by GetConfigurationSpecification()

KinBody.GetDOF((KinBody)arg1) → int :¶

int GetDOF()

Number controllable degrees of freedom of the body.

Only uses _vecjoints and last joint for computation, so can work before _ComputeInternalInformation is called.

KinBody.GetDOFAccelerationLimits((KinBody)arg1) → object :¶

void GetDOFAccelerationLimits(std::vector< dReal > & maxaccelerations, const std::vector< int > & dofindices = std::vector< int >() )

Returns the max acceleration for each DOF.

Parameters

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

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

void GetDOFAccelerationLimits(std::vector< dReal > & maxaccelerations, const std::vector< int > & dofindices = std::vector< int >() )

Returns the max acceleration for each DOF.

Parameters

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

KinBody.GetDOFLimits((KinBody)arg1) → object :¶

void GetDOFLimits(std::vector< dReal > & lowerlimit, std::vector< dReal > & upperlimit, const std::vector< int > & dofindices = std::vector< int >() )

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

Parameters

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

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

void GetDOFLimits(std::vector< dReal > & lowerlimit, std::vector< dReal > & upperlimit, const std::vector< int > & dofindices = std::vector< int >() )

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

Parameters

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

KinBody.GetDOFMaxAccel((KinBody)arg1) → object :¶

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

KinBody.GetDOFMaxTorque((KinBody)arg1) → object :¶

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

KinBody.GetDOFMaxVel((KinBody)arg1) → object :¶

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

KinBody.GetDOFResolutions((KinBody)arg1) → object :¶

void GetDOFResolutions(std::vector< dReal > & v, const std::vector< int > & dofindices = std::vector< int >() )

get the dof resolutions

Parameters

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

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

void GetDOFResolutions(std::vector< dReal > & v, const std::vector< int > & dofindices = std::vector< int >() )

get the dof resolutions

Parameters

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

KinBody.GetDOFTorqueLimits((KinBody)arg1) → object :¶

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

Returns the max torque for each DOF.

GetDOFTorqueLimits( (KinBody)arg1, (object)indices) -> object :

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

Returns the max torque for each DOF.

KinBody.GetDOFValues((KinBody)arg1) → object :¶

void GetDOFValues(std::vector< dReal > & v, const std::vector< int > & dofindices = std::vector< int >() )

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

Parameters

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

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

void GetDOFValues(std::vector< dReal > & v, const std::vector< int > & dofindices = std::vector< int >() )

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

Parameters

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

KinBody.GetDOFVelocities((KinBody)arg1) → object :¶

void GetDOFVelocities(std::vector< dReal > & v, const std::vector< int > & dofindices = std::vector< int >() )

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

Parameters

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

GetDOFVelocities( (KinBody)arg1, (object)indices) -> object :

void GetDOFVelocities(std::vector< dReal > & v, const std::vector< int > & dofindices = std::vector< int >() )

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

Parameters

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

KinBody.GetDOFVelocityLimits((KinBody)arg1) → object :¶

void GetDOFVelocityLimits(std::vector< dReal > & lowerlimit, std::vector< dReal > & upperlimit, const std::vector< int > & dofindices = std::vector< int >() )

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

Parameters

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

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

void GetDOFVelocityLimits(std::vector< dReal > & lowerlimit, std::vector< dReal > & upperlimit, const std::vector< int > & dofindices = std::vector< int >() )

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

Parameters

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

KinBody.GetDOFWeights((KinBody)arg1) → object :¶

void GetDOFWeights(std::vector< dReal > & v, const std::vector< int > & dofindices = std::vector< int >() )

get dof weights

Parameters

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

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

void GetDOFWeights(std::vector< dReal > & v, const std::vector< int > & dofindices = std::vector< int >() )

get dof weights

Parameters

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

KinBody.GetDependencyOrderedJoints((KinBody)arg1) → object :¶

const std::vector< JointPtr > & GetDependencyOrderedJoints()

Returns the joints in hierarchical order starting at the base link.

In the case of closed loops, the joints are returned in the order closest to the root. All the joints affecting a particular joint’s transformation will always come before the joint in the list.

KinBody.GetEnvironmentId((KinBody)arg1) → int :¶

int GetEnvironmentId()

return a unique id of the body used in the environment.

If object is not added to the environment, this will return 0. So checking if GetEnvironmentId() is 0 is a good way to check if object is present in the environment. This id will not be copied when cloning in order to respect another environment’s ids.

KinBody.GetGuiData((KinBody)arg1) → object :¶

UserDataPtr GetViewerData()

See

SetViewerData

KinBody.GetJoint((KinBody)arg1, (str)name) → object :¶

JointPtr GetJoint(const std::string & name)

Return a pointer to the joint with the given name. Search in the regular and passive joints.

KinBody.GetJointFromDOFIndex((KinBody)arg1, (int)dofindex) → object :¶

JointPtr GetJointFromDOFIndex(int dofindex)

Returns the joint that covers the degree of freedom index.

Note that the mapping of joint structures is not the same as the values in GetJointValues since each joint can have more than one degree of freedom.

KinBody.GetJointIndex((KinBody)arg1, (str)name) → int :¶

int GetJointIndex(const std::string & name)

Return the index of the joint with the given name, else -1.

KinBody.GetJoints((KinBody)arg1) → object :¶

const std::vector< JointPtr > & GetJoints()

Returns the joints making up the controllable degrees of freedom of the body.

GetJoints( (KinBody)arg1, (object)indices) -> object :

const std::vector< JointPtr > & GetJoints()

Returns the joints making up the controllable degrees of freedom of the body.

KinBody.GetKinematicsGeometryHash((KinBody)arg1) → str :¶

const std::string & GetKinematicsGeometryHash()

A md5 hash unique to the particular kinematic and geometric structure of a KinBody.

This 32 byte string can be used to check if two bodies have the same kinematic structure and can be used to index into tables when looking for body-specific models. OpenRAVE stores all such models in the OPENRAVE_HOME directory (usually ~/.openrave), indexed by the particular robot/body hashes.

Return

md5 hash string of kinematics/geometry

KinBody.GetLink((KinBody)arg1, (str)name) → object :¶

LinkPtr GetLink(const std::string & name)

return a pointer to the link with the given name

KinBody.GetLinkAccelerations((KinBody)arg1, (object)arg2) → object :¶

void GetLinkAccelerations(const std::vector< dReal > & dofaccelerations, std::vector< std::pair< Vector , Vector > > & linkaccelerations)

Returns the linear and angular accelerations for each link given the dof accelerations.

Parameters

dofaccelerations -

the accelerations of each of the DOF

linkaccelerations -

the linear and angular accelerations of link (in that order) Computes accelerations of the link frames with respect to the world coordinate system are returned. The base angular velocity is used when computing accelerations. The gravity vector from the physics engine is used as the accelerations for the base link and static links. The derivate is taken with respect to the world origin fixed in space (also known as spatial acceleration). The current angles and velocities set on the robot are used. Note that this function calls the internal _ComputeLinkAccelerations function, so for users that are interested in overriding it, override _ComputeLinkAccelerations

KinBody.GetLinkTransformations((KinBody)arg1[, (bool)returndofbranches]) → object :¶

void GetLinkTransformations(std::vector< Transform > & transforms)

get the transformations of all the links at once

KinBody.GetLinkVelocities((KinBody)arg1) → object :¶

void GetLinkVelocities(std::vector< std::pair< Vector , Vector > > & velocities)

Returns the linear and angular velocities for each link.

Parameters

velocities -

The velocities of the link frames with respect to the world coordinate system are returned.

KinBody.GetLinks((KinBody)arg1) → object :¶

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

Returns all the rigid links of the body.

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

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

Returns all the rigid links of the body.

KinBody.GetManageData((KinBody)arg1) → object :¶

ManageDataPtr GetManageData()

KinBody.GetName((KinBody)arg1) → object :¶

const std::string & GetName()

Unique name of the robot.

KinBody.GetNonAdjacentLinks((KinBody)arg1) → object :¶

const std::set< int > & GetNonAdjacentLinks(int adjacentoptions = 0 )

return all possible link pairs that could get in collision.

Parameters

adjacentoptions -

a bitmask of AdjacentOptions values

GetNonAdjacentLinks( (KinBody)arg1, (int)adjacentoptions) -> object :

const std::set< int > & GetNonAdjacentLinks(int adjacentoptions = 0 )

return all possible link pairs that could get in collision.

Parameters

adjacentoptions -

a bitmask of AdjacentOptions values

KinBody.GetPassiveJoints((KinBody)arg1) → object :¶

const std::vector< JointPtr > & GetPassiveJoints()

Returns the passive joints, order does not matter.

A passive joint is not directly controlled by the body’s degrees of freedom so it has no joint index and no dof index. Passive joints allows mimic joints to be hidden from the users. However, there are cases when passive joints are not mimic; for example, suspension mechanism on vehicles.

KinBody.GetPhysicsData((KinBody)arg1) → object :¶

UserDataPtr GetPhysicsData()

See

SetPhysicsData

KinBody.GetRigidlyAttachedLinks((KinBody)arg1, (int)linkindex) → object :¶

void GetRigidlyAttachedLinks(std::vector< boost::shared_ptr< Link > > & vattachedlinks)

Gets all the rigidly attached links to linkindex, also adds the link to the list.

Parameters

vattachedlinks -

the array to insert all links attached to linkindex with the link itself.

KinBody.GetTransform((KinBody)arg1) → object :¶

Transform GetTransform()

queries the transfromation of the first link of the body

KinBody.GetURI((KinBody)arg1) → object :¶

const std::string & GetURI()

the URI used to load the interface (sometimes this is not possible if the definition lies inside an environment file).

KinBody.GetUpdateStamp((KinBody)arg1) → int :¶

int GetUpdateStamp()

Return a unique id for every transformation state change of any link. Used to check if robot state has changed.

The stamp is used by the collision checkers, physics engines, or any other item that needs to keep track of any changes of the KinBody as it moves. Currently stamps monotonically increment for every transformation/joint angle change.

KinBody.GetViewerData((KinBody)arg1) → object :¶

UserDataPtr GetViewerData()

See

SetViewerData

KinBody.GetXMLFilename((KinBody)arg1) → object :¶

const std::string & GetURI()

the URI used to load the interface (sometimes this is not possible if the definition lies inside an environment file).

KinBody.Init((KinBody)arg1, (object)linkinfos, (object)jointinfos) → bool¶

KinBody.InitFromBoxes((KinBody)arg1, (object)boxes, (bool)draw) → bool :¶

bool InitFromBoxes(const std::vector< AABB > & boxes, bool visible)

Create a kinbody with one link composed of an array of aligned bounding boxes.

Parameters

boxes -

the array of aligned bounding boxes that will comprise of the body

visible -

if true, the boxes will be rendered in the scene

boxes is a Nx6 array, first 3 columsn are position, last 3 are extents

KinBody.InitFromGeometries((KinBody)arg1, (object)geometries) → bool :¶

bool InitFromGeometries(const std::list< KinBody::Link::GeometryInfo > & geometries)

Create a kinbody with one link composed of a list of geometries.

Parameters

geometries -

a list of geometry infos to be initialized into new geometry objects, note that the geometry info data is copied

visible -

if true, will be rendered in the scene

KinBody.InitFromSpheres((KinBody)arg1, (object)spherex, (bool)draw) → bool :¶

bool InitFromSpheres(const std::vector< Vector > & spheres, bool visible)

Create a kinbody with one link composed of an array of spheres.

Parameters

spheres -

the XYZ position of the spheres with the W coordinate representing the individual radius

visible -

if true, the boxes will be rendered in the scene

KinBody.InitFromTrimesh((KinBody)arg1, (object)trimesh, (bool)draw) → bool :¶

bool InitFromTrimesh(const Link::TRIMESH & trimesh, bool visible)

Create a kinbody with one link composed of a triangle mesh surface.

Parameters

trimesh -

the triangle mesh

visible -

if true, will be rendered in the scene

KinBody.IsAttached((KinBody)arg1, (KinBody)body) → bool :¶

bool IsAttached(KinBodyConstPtr body)

Return

true if two bodies should be considered as one during collision (ie one is grabbing the other)

KinBody.IsDOFInChain((KinBody)arg1, (int)linkindex1, (int)linkindex2, (int)dofindex) → bool :¶

bool IsDOFInChain(int linkindex1, int linkindex2, int dofindex)

Returns true if the dof index affects the relative transformation between the two links.

Parameters

linkindex1 -

the link index to start the search

linkindex2 -

the link index where the search ends The internal implementation uses KinBody::DoesAffect, therefore mimic indices are correctly handled.

KinBody.IsEnabled((KinBody)arg1) → bool :¶

bool IsEnabled()

Return

true if any link of the KinBody is enabled

KinBody.IsRobot((KinBody)arg1) → bool :¶

bool IsRobot()

Return true if this body is derived from RobotBase.

KinBody.IsVisible((KinBody)arg1) → bool :¶

bool IsVisible()

Return

true if any link of the KinBody is visible.

class KinBody.Joint¶

Bases: Boost.Python.instance

Raises an exception This class cannot be instantiated from Python

AddTorque((Joint)arg1, (object)torques) → None :¶

void AddTorque(const std::vector< dReal > & torques)

Add effort (force or torque) to the joint.

GetAccelerationLimits((Joint)arg1) → object :¶

void GetAccelerationLimits(std::vector< dReal > & vmax, bool bAppend = false )

Returns the max accelerations of the joint.

Parameters

the -

max acceleration

bAppend -

if true will append to the end of the vector instead of erasing it

GetAnchor((Joint)arg1) → object :¶

Vector GetAnchor()

The anchor of the joint in global coordinates.

GetAxis((Joint)arg1[, (int)axis]) → object :¶

Vector GetAxis(int axis = 0 )

The axis of the joint in global coordinates.

Parameters

axis -

the axis to get

GetDOF((Joint)arg1) → int :¶

int GetDOF()

The degrees of freedom of the joint. Each joint supports a max of 3 degrees of freedom.

GetDOFIndex((Joint)arg1) → int :¶

int GetDOFIndex()

Get the degree of freedom index in the body’s DOF array.

This does not index in KinBody::GetJoints() directly! In other words, KinBody::GetDOFValues()[GetDOFIndex()] == GetValues()[0]

GetFirstAttached((Joint)arg1) → Link :¶

LinkPtr GetFirstAttached()

GetFloatParameters((Joint)arg1[, (object)name[, (int)index]]) → object¶

GetHierarchyChildLink((Joint)arg1) → Link :¶

LinkPtr GetHierarchyChildLink()

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

GetHierarchyParentLink((Joint)arg1) → Link :¶

LinkPtr GetHierarchyParentLink()

Return the parent link which the joint measures its angle off from (either GetFirstAttached() or GetSecondAttached())

GetInfo((Joint)arg1) → object¶

GetIntParameters((Joint)arg1[, (object)name[, (int)index]]) → object¶

GetInternalHierarchyAxis((Joint)arg1, (int)axis) → object :¶

Vector GetInternalHierarchyAxis(int axis = 0 )

The axis of the joint in local coordinates.

GetInternalHierarchyLeftTransform((Joint)arg1) → object :¶

Transform GetInternalHierarchyLeftTransform()

Left multiply transform given the base body.

GetInternalHierarchyRightTransform((Joint)arg1) → object :¶

Transform GetInternalHierarchyRightTransform()

Right multiply transform given the base body.

GetJointIndex((Joint)arg1) → int :¶

int GetJointIndex()

Get the joint index into KinBody::GetJoints.

GetLimits((Joint)arg1) → object :¶

void GetLimits(std::vector< dReal > & vLowerLimit, std::vector< dReal > & vUpperLimit, bool bAppend = false )

Get the limits of the joint.

Parameters

vLowerLimit -

the lower limits

vUpperLimit -

the upper limits

bAppend -

if true will append to the end of the vector instead of erasing it

GetMaxAccel((Joint)arg1[, (int)axis]) → float :¶

dReal GetMaxAccel(int iaxis = 0 )

GetMaxTorque((Joint)arg1[, (int)axis]) → float :¶

dReal GetMaxTorque(int iaxis = 0 )

GetMaxVel((Joint)arg1[, (int)axis]) → float :¶

dReal GetMaxVel(int iaxis = 0 )

GetMimicDOFIndices((Joint)arg1[, (int)axis]) → object :¶

void GetMimicDOFIndices(std::vector< int > & vmimicdofs, int axis = 0 )

Returns the set of DOF indices that the computation of a joint axis depends on. Order is arbitrary.

Exceptions

openrave_exception -

Throws an exception if the axis is not mimic. If the mimic joint uses the values of other mimic joints, then the dependent DOFs of that joint are also copied over. Therefore, the dof indices returned can be more than the actual variables used in the equation.

GetMimicEquation((Joint)arg1[, (int)axis[, (int)type[, (str)format]]]) → str :¶

std::string GetMimicEquation(int axis = 0 , int type = 0 , const std::string & format = “” )

If the joint is mimic, returns the equation to compute its value.

Parameters

axis -

the axis index

type -

0 for position, 1 for velocity, 2 for acceleration.

format -

the format the equations are returned in. If empty or “fparser”, equation in fparser format. Also supports: “mathml”.

MathML:Set ‘format’ to “mathml”. The joint variables are specified with <csymbol>. If a targetted joint has more than one degree of freedom, then axis is suffixed with _%d. If ‘type’ is 1 or 2, the partial derivatives are outputted as consecutive <math></math> tags in the same order as MIMIC::_vdofformat

GetName((Joint)arg1) → object :¶

const std::string & GetName()

The unique name of the joint.

GetParent((Joint)arg1) → KinBody :¶

KinBodyPtr GetParent()

GetResolution((Joint)arg1, (int)axis) → float :¶

dReal GetResolution(int iaxis = 0 )

The discretization of the joint used when line-collision checking.

The resolutions are set as large as possible such that the joint will not go through obstacles of determined size.

GetResolutions((Joint)arg1) → object :¶

void GetResolutions(std::vector< dReal > & resolutions, bool bAppend = false )

gets all resolutions for the joint axes

Parameters

bAppend -

if true will append to the end of the vector instead of erasing it

GetSecondAttached((Joint)arg1) → Link :¶

LinkPtr GetSecondAttached()

GetTorqueLimits((Joint)arg1) → object :¶

void GetTorqueLimits(std::vector< dReal > & vmax, bool bAppend = false )

Returns the max torques of the joint.

Parameters

the -

max torque

bAppend -

if true will append to the end of the vector instead of erasing it

GetType((Joint)arg1) → JointType :¶

JointType GetType()

GetValue((Joint)arg1, (int)arg2) → float¶

GetValues((Joint)arg1) → object :¶

void GetValues(std::vector< dReal > & values, bool bAppend = false )

Return all the joint values with the correct offsets applied.

Parameters

bAppend -

if true will append to the end of the vector instead of erasing it

Return

degrees of freedom of the joint (even if pValues is NULL)

GetVelocities((Joint)arg1) → object :¶

void GetVelocities(std::vector< dReal > & values, bool bAppend = false )

Gets the joint velocities.

Parameters

bAppend -

if true will append to the end of the vector instead of erasing it

Return

the degrees of freedom of the joint (even if pValues is NULL)

GetVelocityLimits((Joint)arg1) → object :¶

void GetVelocityLimits(std::vector< dReal > & vmax, bool bAppend = false )

Returns the max velocities of the joint.

Parameters

the -

max velocity

bAppend -

if true will append to the end of the vector instead of erasing it

GetWeight((Joint)arg1, (int)axis) → float :¶

dReal GetWeight(int axis = 0 )

The weight associated with a joint’s axis for computing a distance in the robot configuration space.

GetWeights((Joint)arg1) → object :¶

void GetWeights(std::vector< dReal > & weights, bool bAppend = false )

gets all weights for the joint axes

Parameters

bAppend -

if true will append to the end of the vector instead of erasing it

GetWrapOffset((Joint)arg1[, (int)axis]) → float :¶

dReal GetWrapOffset(int iaxis = 0 )

Return internal offset parameter that determines the branch the angle centers on.

Parameters

iaxis -

the axis to get the offset from Wrap offsets are needed for rotation joints since the range is limited to 2*pi. This allows the wrap offset to be set so the joint can function in [-pi+offset,pi+offset]..

IsCircular((Joint)arg1, (int)arg2) → bool :¶

bool IsCircular(int iaxis)

Return true if joint axis has an identification at some of its lower and upper limits.

An identification of the lower and upper limits means that once the joint reaches its upper limits, it is also at its lower limit. The most common identification on revolute joints at -pi and pi. ‘circularity’ means the joint does not stop at limits. Although currently not developed, it could be possible to support identification for joints that are not revolute.

IsMimic((Joint)arg1[, (int)axis]) → bool :¶

bool IsMimic(int axis = -1 )

Returns true if a particular axis of the joint is mimiced.

Parameters

axis -

the axis to query. When -1 returns true if any of the axes have mimic joints

IsPrismatic((Joint)arg1, (int)arg2) → bool :¶

bool IsPrismatic(int iaxis)

returns true if the axis describes a translation around an axis.

Parameters

iaxis -

the axis of the joint to return the results for

IsRevolute((Joint)arg1, (int)arg2) → bool :¶

bool IsRevolute(int iaxis)

returns true if the axis describes a rotation around an axis.

Parameters

iaxis -

the axis of the joint to return the results for

IsStatic((Joint)arg1) → bool :¶

bool IsStatic()

Return true if joint can be treated as a static binding (ie all limits are 0)

SetAccelerationLimits((Joint)arg1, (object)maxlimits) → None :¶

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

See

GetAccelerationLimits

SetFloatParameters((Joint)arg1, (str)arg2, (object)arg3) → None¶

SetIntParameters((Joint)arg1, (str)arg2, (object)arg3) → None¶

SetLimits((Joint)arg1, (object)lower, (object)upper) → None :¶

void SetLimits(const std::vector< dReal > & lower, const std::vector< dReal > & upper)

See

GetLimits

SetMimicEquations((Joint)arg1, (int)axis, (str)poseq, (str)veleq, (str)acceleq) → None :¶

void SetMimicEquations(int axis, const std::string & poseq, const std::string & veleq, const std::string & acceleq = “” )

Sets the mimic properties of the joint.

The equations can use the joint names directly in the equation, which represent the position of the joint. Any non-mimic joint part of KinBody::GetJoints() can be used in the computation of the values. If a joint has more than one degree of freedom, then suffix it ‘_’ and the axis index. For example universaljoint_0 * 10 + sin(universaljoint_1).See for a full description of the equation formats.The velocity and acceleration equations are specified in terms of partial derivatives, which means one expression needs to be specified per degree of freedom of used. In order to separate the expressions use “|name ...”. The name should immediately follow ‘|‘. For example:|universaljoint_0 10 |universaljoint_1 10*cos(universaljoint_1)If there is only one variable used in the position equation, then the equation can be specified directly without using “{}”.Parameters

axis -

the axis to set the properties for.

poseq -

Equation for joint’s position. If it is empty, the mimic properties are turned off for this joint.

veleq -

First-order partial derivatives of poseq with respect to all used DOFs. Only the variables used in poseq are allowed to be used. If poseq is not empty, this is required.

acceleq -

Second-order partial derivatives of poseq with respect to all used DOFs. Only the variables used in poseq are allowed to be used. Optional. Exceptions

openrave_exception -

Throws an exception if the mimic equation is invalid in any way.

SetResolution((Joint)arg1, (float)resolution) → None :¶

void SetResolution(dReal resolution, int iaxis = 0 )

SetTorqueLimits((Joint)arg1, (object)maxlimits) → None :¶

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

See

GetTorqueLimits

SetVelocityLimits((Joint)arg1, (object)maxlimits) → None :¶

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

See

GetVelocityLimits

SetWeights((Joint)arg1, (object)weights) → None :¶

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

See

GetWeight

SetWrapOffset((Joint)arg1, (float)offset[, (int)axis]) → None :¶

void SetWrapOffset(dReal offset, int iaxis = 0 )

See

GetWrapOffset

SubtractValue((Joint)arg1, (float)value0, (float)value1, (int)axis) → float :¶

dReal SubtractValue(dReal value1, dReal value2, int iaxis)

Returns the configuration difference value1-value2 for axis i.

Takes into account joint limits and wrapping of circular joints.

SubtractValues((Joint)arg1, (object)values0, (object)values1) → object :¶

void SubtractValues(std::vector< dReal > & values1, const std::vector< dReal > & values2)

Computes the configuration difference values1-values2 and stores it in values1.

Takes into account joint limits and wrapping of circular joints.

Type¶

alias of JointType

UpdateAndGetInfo((Joint)arg1) → object¶

UpdateInfo((Joint)arg1) → None¶

class KinBody.JointInfo¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

class KinBody.JointType¶

Bases: Boost.Python.enum

JointType

The type of joint movement.

Non-special joints that are combinations of revolution and prismatic joints. The first 4 bits specify the joint DOF, the next bits specify whether the joint is revolute (0) or prismatic (1). There can be also special joint types that are valid if the JointSpecialBit is set.For multi-dof joints, the order is transform(parentlink) * transform(axis0) * transform(axis1) ...

Hinge = openravepy.openravepy_int.JointType.Hinge¶

Hinge2 = openravepy.openravepy_int.JointType.Hinge2¶

None = openravepy.openravepy_int.JointType.None¶

PP = openravepy.openravepy_int.JointType.PP¶

PR = openravepy.openravepy_int.JointType.PR¶

Prismatic = openravepy.openravepy_int.JointType.Prismatic¶

RP = openravepy.openravepy_int.JointType.RP¶

RR = openravepy.openravepy_int.JointType.RR¶

Revolute = openravepy.openravepy_int.JointType.Revolute¶

Slider = openravepy.openravepy_int.JointType.Slider¶

Spherical = openravepy.openravepy_int.JointType.Spherical¶

Trajectory = openravepy.openravepy_int.JointType.Trajectory¶

Universal = openravepy.openravepy_int.JointType.Universal¶

names = {'PR': openravepy.openravepy_int.JointType.PR, 'Spherical': openravepy.openravepy_int.JointType.Spherical, 'None': openravepy.openravepy_int.JointType.None, 'RP': openravepy.openravepy_int.JointType.RP, 'RR': openravepy.openravepy_int.JointType.RR, 'Prismatic': openravepy.openravepy_int.JointType.Prismatic, 'Universal': openravepy.openravepy_int.JointType.Universal, 'Hinge2': openravepy.openravepy_int.JointType.Hinge2, 'PP': openravepy.openravepy_int.JointType.PP, 'Hinge': openravepy.openravepy_int.JointType.Hinge, 'Slider': openravepy.openravepy_int.JointType.Slider, 'Revolute': openravepy.openravepy_int.JointType.Revolute, 'Trajectory': openravepy.openravepy_int.JointType.Trajectory}¶

values = {0: openravepy.openravepy_int.JointType.None, 1: openravepy.openravepy_int.JointType.Revolute, 2: openravepy.openravepy_int.JointType.RR, 50: openravepy.openravepy_int.JointType.PP, 2147483652: openravepy.openravepy_int.JointType.Trajectory, 2147483649: openravepy.openravepy_int.JointType.Universal, 2147483650: openravepy.openravepy_int.JointType.Hinge2, 34: openravepy.openravepy_int.JointType.PR, 17: openravepy.openravepy_int.JointType.Prismatic, 18: openravepy.openravepy_int.JointType.RP, 2147483651: openravepy.openravepy_int.JointType.Spherical}¶

class KinBody.KinBodyStateSaver¶

Bases: Boost.Python.instance

__init__( (object)arg1, (KinBody)body) -> None

__init__( (object)arg1, (KinBody)body, (object)options) -> None

GetBody((KinBodyStateSaver)arg1) → object¶

Release((KinBodyStateSaver)arg1) → None¶

Restore((KinBodyStateSaver)arg1[, (KinBody)body]) → None¶

class KinBody.Link¶

Bases: Boost.Python.instance

Raises an exception This class cannot be instantiated from Python

ComputeAABB((Link)arg1) → object :¶

AABB ComputeAABB()

Compute the aabb of all the geometries of the link in the world coordinate system.

ComputeLocalAABB((Link)arg1, (object)arg2) → object¶

Enable((Link)arg1, (bool)enable) → None :¶

void Enable(bool enable)

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

GeomProperties¶

alias of Geometry

GeomType¶

alias of GeometryType

class Geometry¶

Bases: Boost.Python.instance

Raises an exception This class cannot be instantiated from Python

ComputeAABB((Geometry)arg1, (object)transform) → object :¶

AABB ComputeAABB(const Transform & trans)

returns an axis aligned bounding box given that the geometry is transformed by trans

GetAmbientColor((Geometry)arg1) → object :¶

const RaveVector< float > & GetAmbientColor()

GetBoxExtents((Geometry)arg1) → object :¶

const Vector & GetBoxExtents()

GetCollisionMesh((Geometry)arg1) → object :¶

const TRIMESH & GetCollisionMesh()

returns the local collision mesh

GetCylinderHeight((Geometry)arg1) → float :¶

dReal GetCylinderHeight()

GetCylinderRadius((Geometry)arg1) → float :¶

dReal GetCylinderRadius()

GetDiffuseColor((Geometry)arg1) → object :¶

const RaveVector< float > & GetDiffuseColor()

GetInfo((Geometry)arg1) → object¶

GetRenderFilename((Geometry)arg1) → object :¶

const std::string & GetRenderFilename()

GetRenderScale((Geometry)arg1) → object :¶

const Vector & GetRenderScale()

GetSphereRadius((Geometry)arg1) → float :¶

dReal GetSphereRadius()

GetTransform((Geometry)arg1) → object :¶

const Transform & GetTransform()

get local geometry transform

GetTransparency((Geometry)arg1) → float :¶

float GetTransparency()

GetType((Geometry)arg1) → GeometryType :¶

GeomType GetType()

IsDraw((Geometry)arg1) → bool :¶

bool IsDraw()

IsModifiable((Geometry)arg1) → bool :¶

bool IsModifiable()

IsVisible((Geometry)arg1) → bool :¶

bool IsVisible()

SetAmbientColor((Geometry)arg1, (object)color) → None :¶

void SetAmbientColor(const RaveVector< float > & color)

override ambient color of geometry material

SetCollisionMesh((Geometry)arg1, (object)trimesh) → None :¶

void SetCollisionMesh(const TRIMESH & mesh)

sets a new collision mesh and notifies every registered callback about it

SetDiffuseColor((Geometry)arg1, (object)color) → None :¶

void SetDiffuseColor(const RaveVector< float > & color)

override diffuse color of geometry material

SetDraw((Geometry)arg1, (bool)draw) → None :¶

void SetDraw(bool bDraw)

SetRenderFilename((Geometry)arg1, (str)color) → None :¶

void SetRenderFilename(const std::string & renderfilename)

sets a new render filename for the geometry. This does not change the collision

SetTransparency((Geometry)arg1, (float)transparency) → None :¶

void SetTransparency(float f)

set transparency level (0 is opaque)

Type¶

alias of GeometryType

class KinBody.Link.GeometryInfo¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

KinBody.Link.GetCOMOffset((Link)arg1) → object :¶

Vector GetCOMOffset()

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

const TRIMESH & GetCollisionData()

KinBody.Link.GetFloatParameters((Link)arg1[, (object)name[, (int)index]]) → object¶

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

const std::vector< GeometryPtr > & GetGeometries()

returns a list of all the geometry objects.

KinBody.Link.GetGlobalCOM((Link)arg1) → object :¶

Vector GetGlobalCOM()

return center of mass of the link in the global coordinate system

KinBody.Link.GetGlobalMassFrame((Link)arg1) → object :¶

Transform GetGlobalMassFrame()

return the mass frame in the global coordinate system that holds the center of mass and principal axes for inertia.

KinBody.Link.GetIndex((Link)arg1) → int :¶

int GetIndex()

unique index into parent KinBody::GetLinks vector

KinBody.Link.GetInfo((Link)arg1) → object¶

KinBody.Link.GetIntParameters((Link)arg1[, (object)name[, (int)index]]) → object¶

KinBody.Link.GetLocalCOM((Link)arg1) → object :¶

Vector GetLocalCOM()

return center of mass offset in the link’s local coordinate frame

KinBody.Link.GetLocalInertia((Link)arg1) → object :¶

TransformMatrix GetLocalInertia()

return inertia in link’s local coordinate frame. The translation component is the the COM in the link’s frame.

KinBody.Link.GetLocalMassFrame((Link)arg1) → object :¶

const Transform & GetLocalMassFrame()

return the mass frame in the link’s local coordinate system that holds the center of mass and principal axes for inertia.

KinBody.Link.GetMass((Link)arg1) → float :¶

dReal GetMass()

KinBody.Link.GetName((Link)arg1) → object :¶

const std::string & GetName()

KinBody.Link.GetParent((Link)arg1) → object :¶

KinBodyPtr GetParent()

parent body that link belong to.

KinBody.Link.GetParentLinks((Link)arg1) → object :¶

void GetParentLinks(std::vector< boost::shared_ptr< Link > > & vParentLinks)

Return all the direct parent links in the kinematics hierarchy of this link.

Parameters

filled -

with the parent links A parent link is is immediately connected to this link by a joint and has a path to the root joint so that it is possible to compute this link’s transformation from its parent.

KinBody.Link.GetPrincipalMomentsOfInertia((Link)arg1) → object :¶

const Vector & GetPrincipalMomentsOfInertia()

return the principal moments of inertia inside the mass frame

KinBody.Link.GetRigidlyAttachedLinks((Link)arg1) → object :¶

void GetRigidlyAttachedLinks(std::vector< boost::shared_ptr< Link > > & vattachedlinks)

Gets all the rigidly attached links to linkindex, also adds the link to the list.

Parameters

vattachedlinks -

the array to insert all links attached to linkindex with the link itself.

KinBody.Link.GetTransform((Link)arg1) → object :¶

Transform GetTransform()

Return the current transformation of the link in the world coordinate system.

KinBody.Link.GetVelocity((Link)arg1) → object :¶

void GetVelocity(Vector & linearvel, Vector & angularvel)

get the velocity of the link

Parameters

linearvel -

the translational velocity

angularvel -

is the rotation axis * angular speed

KinBody.Link.InitGeometries((Link)arg1, (object)geometries) → None¶

KinBody.Link.IsEnabled((Link)arg1) → bool :¶

bool IsEnabled()

returns true if the link is enabled.

See

Enable

KinBody.Link.IsParentLink((Link)arg1, (Link)arg2) → bool :¶

bool IsParentLink(boost::shared_ptr< Link const > plink)

Tests if a link is a direct parent.

Parameters

link -

The link to test if it is one of the parents of this link.

See

GetParentLinks

KinBody.Link.IsRigidlyAttached((Link)arg1, (Link)arg2) → bool :¶

bool IsRigidlyAttached(boost::shared_ptr< Link const > plink)

returns true if plink is rigidily attahced to this link.

KinBody.Link.IsStatic((Link)arg1) → bool :¶

bool IsStatic()

Indicates a static body that does not move with respect to the root link.

Static should be used when an object has infinite mass and shouldn’t be affected by physics (including gravity). Collision still works.

KinBody.Link.IsVisible((Link)arg1) → bool :¶

bool IsVisible()

Return

true if any geometry of the link is visible.

KinBody.Link.SetFloatParameters((Link)arg1, (str)arg2, (object)arg3) → None¶

KinBody.Link.SetForce((Link)arg1, (object)force, (object)pos, (bool)add) → None :¶

void SetForce(const Vector & force, const Vector & pos, bool add)

Parameters

force -

the direction and magnitude of the force

pos -

in the world where the force is getting applied

add -

if true, force is added to previous forces, otherwise it is set adds an external force at pos (absolute coords)

KinBody.Link.SetIntParameters((Link)arg1, (str)arg2, (object)arg3) → None¶

KinBody.Link.SetLocalMassFrame((Link)arg1, (object)massframe) → None :¶

void SetLocalMassFrame(const Transform & massframe)

sets a new mass frame with respect to the link coordinate system

KinBody.Link.SetMass((Link)arg1, (float)mass) → None :¶

void SetMass(dReal mass)

set a new mass

KinBody.Link.SetPrincipalMomentsOfInertia((Link)arg1, (object)inertiamoments) → None :¶

void SetPrincipalMomentsOfInertia(const Vector & inertiamoments)

sets new principal moments of inertia (with respect to the mass frame)

KinBody.Link.SetStatic((Link)arg1, (bool)static) → None :¶

void SetStatic(bool bStatic)

sets a link to be static.

Because this can affect the kinematics, it requires the body’s internal structures to be recomputed

KinBody.Link.SetTorque((Link)arg1, (object)torque, (bool)add) → None :¶

void SetTorque(const Vector & torque, bool add)

Parameters

add -

if true, torque is added to previous torques, otherwise it is set adds torque to a body (absolute coords)

KinBody.Link.SetTransform((Link)arg1, (object)transform) → None :¶

void SetTransform(const Transform & transform)

Sets the transform of the link regardless of kinematics.

Parameters

t -

the new transformation

KinBody.Link.SetVelocity((Link)arg1, (object)arg2, (object)arg3) → None :¶

void SetVelocity(const Vector & linearvel, const Vector & angularvel)

Parameters

linearvel -

the translational velocity

angularvel -

is the rotation axis * angular speed forces the velocity of the link

KinBody.Link.SetVisible((Link)arg1, (bool)visible) → bool :¶

bool SetVisible(bool visible)

Sets all the geometries of the link as visible or non visible.

Return

true if changed

KinBody.Link.UpdateAndGetInfo((Link)arg1) → object¶

KinBody.Link.UpdateInfo((Link)arg1) → None¶

class KinBody.LinkInfo¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

class KinBody.ManageData¶

Bases: Boost.Python.instance

Raises an exception This class cannot be instantiated from Python

GetData((ManageData)arg1) → object :¶

XMLReadableConstPtr GetData()

returns a pointer to the data used to initialize the BODY with AddKinBody. if psize is not NULL, will be filled with the size of the data in bytes This function will be used to restore bodies that were removed

GetOffsetLink((ManageData)arg1) → Link :¶

KinBody::LinkPtr GetOffsetLink()

particular link that sensor system is tracking. All transformations describe this link.

GetSystem((ManageData)arg1) → object :¶

SensorSystemBasePtr GetSystem()

IsEnabled((ManageData)arg1) → bool :¶

bool IsEnabled()

true if should update openrave body

IsLocked((ManageData)arg1) → bool :¶

bool IsLocked()

if true, the vision system should not destroy this object once it stops being present

IsPresent((ManageData)arg1) → bool :¶

bool IsPresent()

true if the object is being updated by the system due to its presence in the real environment

Lock((ManageData)arg1, (bool)dolock) → bool :¶

bool Lock(bool bDoLock)

set a lock on a particular body

class KinBody.SaveParameters¶

Bases: Boost.Python.enum

SaveParameters

Parameters passed into the state savers to control what information gets saved.

ActiveDOF = openravepy.openravepy_int.SaveParameters.ActiveDOF¶

ActiveManipulator = openravepy.openravepy_int.SaveParameters.ActiveManipulator¶

GrabbedBodies = openravepy.openravepy_int.SaveParameters.GrabbedBodies¶

JointMaxVelocityAndAcceleration = openravepy.openravepy_int.SaveParameters.JointMaxVelocityAndAcceleration¶

LinkEnable = openravepy.openravepy_int.SaveParameters.LinkEnable¶

LinkTransformation = openravepy.openravepy_int.SaveParameters.LinkTransformation¶

names = {'LinkTransformation': openravepy.openravepy_int.SaveParameters.LinkTransformation, 'ActiveDOF': openravepy.openravepy_int.SaveParameters.ActiveDOF, 'JointMaxVelocityAndAcceleration': openravepy.openravepy_int.SaveParameters.JointMaxVelocityAndAcceleration, 'GrabbedBodies': openravepy.openravepy_int.SaveParameters.GrabbedBodies, 'LinkEnable': openravepy.openravepy_int.SaveParameters.LinkEnable, 'ActiveManipulator': openravepy.openravepy_int.SaveParameters.ActiveManipulator}¶

values = {262144: openravepy.openravepy_int.SaveParameters.GrabbedBodies, 1: openravepy.openravepy_int.SaveParameters.LinkTransformation, 2: openravepy.openravepy_int.SaveParameters.LinkEnable, 65536: openravepy.openravepy_int.SaveParameters.ActiveDOF, 8: openravepy.openravepy_int.SaveParameters.JointMaxVelocityAndAcceleration, 131072: openravepy.openravepy_int.SaveParameters.ActiveManipulator}¶

KinBody.SetBodyTransformations((KinBody)arg1, (object)arg2, (object)transforms) → None :¶

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

sets the transformations of all the links at once

KinBody.SetConfigurationValues((KinBody)arg1, (object)values[, (int)checklimits]) → None :¶

void SetConfigurationValues(std::vector< dReal >::const_iterator itvalues, uint32_t checklimits = CLA_CheckLimits )

sets joint values and transform of the body using configuration values as specified by GetConfigurationSpecification()

Parameters

itvalues -

the iterator to the vector containing the dof values. Must have GetConfigurationSpecification().GetDOF() values!

checklimits -

one of CheckLimitsAction and will excplicitly check the joint limits before setting the values and clamp them.

KinBody.SetDOFAccelerationLimits((KinBody)arg1, (object)limits) → None :¶

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

See

GetDOFAccelerationLimits

KinBody.SetDOFLimits((KinBody)arg1, (object)lower, (object)upper) → None :¶

void SetDOFLimits(const std::vector< dReal > & lower, const std::vector< dReal > & upper)

See

GetDOFLimits

KinBody.SetDOFTorqueLimits((KinBody)arg1, (object)limits) → None :¶

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

See

GetDOFTorqueLimits

KinBody.SetDOFTorques((KinBody)arg1, (object)torques, (bool)add) → None :¶

void SetDOFTorques(const std::vector< dReal > & torques, bool add)

Adds a torque to every joint.

Parameters

bAdd -

if true, adds to previous torques, otherwise resets the torques on all bodies and starts from 0

KinBody.SetDOFValues((KinBody)arg1, (object)values) → None :¶

void SetDOFValues(const std::vector< dReal > & values, uint32_t checklimits = CLA_CheckLimits , const std::vector< int > & dofindices = std::vector< int >() )

Sets the joint values of the robot.

Parameters

values -

the values to set the joint angles (ordered by the dof indices)

checklimits -

one of CheckLimitsAction and will excplicitly check the joint limits before setting the values and clamp them.

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

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

void SetDOFValues(const std::vector< dReal > & values, uint32_t checklimits = CLA_CheckLimits , const std::vector< int > & dofindices = std::vector< int >() )

Sets the joint values of the robot.

Parameters

values -

the values to set the joint angles (ordered by the dof indices)

checklimits -

one of CheckLimitsAction and will excplicitly check the joint limits before setting the values and clamp them.

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

SetDOFValues( (KinBody)arg1, (object)values, (object)dofindices, (int)checklimits) -> None :

void SetDOFValues(const std::vector< dReal > & values, uint32_t checklimits = CLA_CheckLimits , const std::vector< int > & dofindices = std::vector< int >() )

Sets the joint values of the robot.

Parameters

values -

the values to set the joint angles (ordered by the dof indices)

checklimits -

one of CheckLimitsAction and will excplicitly check the joint limits before setting the values and clamp them.

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

KinBody.SetDOFVelocities((KinBody)arg1, (object)dofvelocities) → None :¶

void SetDOFVelocities(const std::vector< dReal > & dofvelocities, uint32_t checklimits = CLA_CheckLimits )

Sets the velocity of the joints.

Parameters

dofvelocities -

• velocities of each of the degrees of freeom

checklimits -

if >0, will excplicitly check the joint velocity limits before setting the values and clamp them. If == 1, then will warn if the limits are overboard, if == 2, then will not warn (used for code that knows it’s giving bad values) Copies the current velocity of the base link and calls SetDOFVelocities(linearvel,angularvel,vDOFVelocities)

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

void SetDOFVelocities(const std::vector< dReal > & dofvelocities, const Vector & linearvel, const Vector & angularvel, uint32_t checklimits = CLA_CheckLimits )

Sets the velocity of the base link and each of the joints.

Parameters

linearvel -

linear velocity of base link

angularvel -

angular velocity rotation_axis*theta_dot

dofvelocities -

• velocities of each of the degrees of freeom

checklimits -

one of CheckLimitsAction and will excplicitly check the joint velocity limits before setting the values and clamp them. Computes internally what the correponding velocities of each of the links should be in order to achieve consistent results with the joint velocities. Sends the velocities to the physics engine. Velocities correspond to the link’s coordinate system origin.

SetDOFVelocities( (KinBody)arg1, (object)dofvelocities, (int)checklimits, (object)indices) -> None

SetDOFVelocities( (KinBody)arg1, (object)dofvelocities, (object)linear, (object)angular, (int)checklimits) -> None :

void SetDOFVelocities(const std::vector< dReal > & dofvelocities, const Vector & linearvel, const Vector & angularvel, uint32_t checklimits = CLA_CheckLimits )

Sets the velocity of the base link and each of the joints.

Parameters

linearvel -

linear velocity of base link

angularvel -

angular velocity rotation_axis*theta_dot

dofvelocities -

• velocities of each of the degrees of freeom

checklimits -

one of CheckLimitsAction and will excplicitly check the joint velocity limits before setting the values and clamp them. Computes internally what the correponding velocities of each of the links should be in order to achieve consistent results with the joint velocities. Sends the velocities to the physics engine. Velocities correspond to the link’s coordinate system origin.

KinBody.SetDOFVelocityLimits((KinBody)arg1, (object)limits) → None :¶

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

See

GetDOFVelocityLimits

KinBody.SetDOFWeights((KinBody)arg1, (object)weights) → None :¶

void SetDOFWeights(const std::vector< dReal > & weights, const std::vector< int > & dofindices = std::vector< int >() )

sets dof weights

Parameters

dofindices -

the dof indices to set the values for. If empty, will use all the dofs

KinBody.SetJointTorques((KinBody)arg1, (object)torques, (bool)add) → None :¶

void SetDOFTorques(const std::vector< dReal > & torques, bool add)

Adds a torque to every joint.

Parameters

bAdd -

if true, adds to previous torques, otherwise resets the torques on all bodies and starts from 0

KinBody.SetJointValues((KinBody)arg1, (object)values) → None :¶

void SetDOFValues(const std::vector< dReal > & values, uint32_t checklimits = CLA_CheckLimits , const std::vector< int > & dofindices = std::vector< int >() )

Sets the joint values of the robot.

Parameters

values -

the values to set the joint angles (ordered by the dof indices)

checklimits -

one of CheckLimitsAction and will excplicitly check the joint limits before setting the values and clamp them.

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

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

void SetDOFValues(const std::vector< dReal > & values, uint32_t checklimits = CLA_CheckLimits , const std::vector< int > & dofindices = std::vector< int >() )

Sets the joint values of the robot.

Parameters

values -

the values to set the joint angles (ordered by the dof indices)

checklimits -

one of CheckLimitsAction and will excplicitly check the joint limits before setting the values and clamp them.

dofindices -

the dof indices to return the values for. If empty, will compute for all the dofs

KinBody.SetLinkTransformations((KinBody)arg1, (object)transforms[, (object)dofbranches]) → None :¶

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

sets the transformations of all the links at once

KinBody.SetLinkVelocities((KinBody)arg1, (object)velocities) → None :¶

void SetLinkVelocities(const std::vector< std::pair< Vector , Vector > > & velocities)

sets the link velocities

KinBody.SetName((KinBody)arg1, (str)name) → None :¶

void SetName(const std::string & name)

Set the name of the robot, notifies the environment and checks for uniqueness.

KinBody.SetNonCollidingConfiguration((KinBody)arg1) → None :¶

void SetNonCollidingConfiguration()

Treats the current pose as a pose not in collision, which sets the adjacent pairs of links.

KinBody.SetTransform((KinBody)arg1, (object)transform) → None :¶

void SetTransform(const Transform & transform)

胴体の絶対姿勢を設定、残りのリンクは運動学の構造に従って変換される．

Parameters

transform -

変換行列

KinBody.SetTransformWithDOFValues((KinBody)arg1, (object)transform, (object)values) → None :¶

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

Sets the joint values and transformation of the body.

Parameters

values -

the values to set the joint angles (ordered by the dof indices)

transform -

represents the transformation of the first body.

checklimits -

one of CheckLimitsAction and will excplicitly check the joint limits before setting the values and clamp them.

KinBody.SetTransformWithJointValues((KinBody)arg1, (object)transform, (object)values) → None :¶

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

Sets the joint values and transformation of the body.

Parameters

values -

the values to set the joint angles (ordered by the dof indices)

transform -

represents the transformation of the first body.

checklimits -

one of CheckLimitsAction and will excplicitly check the joint limits before setting the values and clamp them.

KinBody.SetVelocity((KinBody)arg1, (object)linear, (object)angular) → bool :¶

bool SetVelocity(const Vector & linearvel, const Vector & angularvel)

Set the velocity of the base link, rest of links are set to a consistent velocity so entire robot moves correctly.

Parameters

linearvel -

linear velocity

angularvel -

is the rotation axis * angular speed

KinBody.SetVisible((KinBody)arg1, (bool)visible) → bool :¶

bool SetVisible(bool visible)

Sets all the links as visible or not visible.

Return

true if changed

KinBody.SetZeroConfiguration((KinBody)arg1) → None :¶

void SetZeroConfiguration()

Sets the joint offsets so that the current configuration becomes the new zero state of the robot.

When this function returns, the returned DOF values should be all zero for controllable joints. Mimic equations will use the new offsetted values when computing their joints. This is primarily used for calibrating a robot’s zero position

KinBody.SubtractDOFValues((KinBody)arg1, (object)values0, (object)values1) → object :¶

void SubtractDOFValues(std::vector< dReal > & values1, const std::vector< dReal > & values2, const std::vector< int > & dofindices = std::vector< int >() )

Computes the configuration difference values1-values2 and stores it in values1.

Parameters

inout] -

values1 the result is stored back in this

values2 -

dofindices -

the dof indices to compute the subtraction for. If empty, will compute for all the dofs Takes into account joint limits and wrapping of circular joints.

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

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

only used for hashes...

class openravepy.openravepy_int.Module¶

Bases: openravepy.openravepy_int.Interface

Raises an exception This class cannot be instantiated from Python

Destroy((Module)arg1) → None¶

SimulationStep((Module)arg1, (float)arg2) → bool¶

class openravepy.openravepy_int.PhysicsEngine¶

Bases: openravepy.openravepy_int.Interface

Raises an exception This class cannot be instantiated from Python

AddJointTorque((PhysicsEngine)arg1, (object)arg2, (object)arg3) → bool :¶

bool AddJointTorque(KinBody::JointPtr pjoint, const std::vector< dReal > & pTorques)

Parameters

pjoint -

• the joint the torque is added to

pTorques -

• the torques added to the joint. Pointer because the joint dof can be greater than 1. adds torque to a joint

DestroyEnvironment((PhysicsEngine)arg1) → None :¶

void DestroyEnvironment()

called when environment switches to a different physics engine has to clear/deallocate any memory associated with KinBody::_pPhysicsData

GetGravity((PhysicsEngine)arg1) → object :¶

Vector GetGravity()

GetLinkForceTorque((PhysicsEngine)arg1, (object)arg2) → object :¶

bool GetLinkForceTorque(KinBody::LinkConstPtr link, Vector & force, Vector & torque)

Parameters

link -

a constant pointer to a link

force -

current force on the COM of the link

torque -

current torque on the COM of the link

GetLinkVelocities((PhysicsEngine)arg1, (object)arg2) → object :¶

bool GetLinkVelocities(KinBodyConstPtr body, std::vector< std::pair< Vector , Vector > > & velocities)

Sets the velocities for each link, velocities correspond to the link’s coordinate system origin.

Parameters

velocities -

the linear and angular (axis * angular_speed) velocities for each link.

GetLinkVelocity((PhysicsEngine)arg1, (object)arg2) → object :¶

bool GetLinkVelocity(KinBody::LinkConstPtr link, Vector & linearvel, Vector & angularvel)

Gets the velocity of a link, velocities correspond to the link’s coordinate system origin.

Parameters

linearvel -

• linear velocity of base link

angularvel -

• angular velocity rotation_axis*theta_dot

GetPhysicsOptions((PhysicsEngine)arg1) → int :¶

int GetPhysicsOptions()

InitEnvironment((PhysicsEngine)arg1) → bool :¶

bool InitEnvironment()

called when environment sets this physics engine, engine assumes responsibility for KinBody::_pPhysicsData

InitKinBody((PhysicsEngine)arg1, (KinBody)arg2) → bool :¶

bool InitKinBody(KinBodyPtr body)

notified when a new body has been initialized in the environment

SetBodyForce((PhysicsEngine)arg1, (object)arg2, (object)arg3, (object)arg4, (bool)arg5) → bool :¶

bool SetBodyForce(KinBody::LinkPtr link, const Vector & force, const Vector & position, bool bAdd)

Parameters

force -

the direction and magnitude of the force

position -

in the world where the force is getting applied

bAdd -

if true, force is added to previous forces, otherwise it is set add a force at a particular position in a link

SetBodyTorque((PhysicsEngine)arg1, (object)arg2, (object)arg3, (bool)arg4) → bool :¶

bool SetBodyTorque(KinBody::LinkPtr link, const Vector & torque, bool bAdd)

Parameters

link -

the link to add a torque to

torque -

torque vector

bAdd -

if true, torque is added to previous torques, otherwise it is set adds torque to a body (absolute coords)

SetGravity((PhysicsEngine)arg1, (object)arg2) → None :¶

void SetGravity(const Vector & gravity)

set the gravity direction

Parameters

joint -

force -

current accumulated force on the COM of the link

torque -

current accumulated torque on the COM of the link

SetLinkVelocities((PhysicsEngine)arg1, (object)arg2, (object)body, (object)velocities) → bool :¶

bool SetLinkVelocities(KinBodyPtr body, const std::vector< std::pair< Vector , Vector > > & velocities)

Sets the velocities for each link, velocities correspond to the link’s coordinate system origin.

Parameters

body -

the body to query velocities from.

velocities -

sets the linear and angular (axis * angular_speed) velocities for each link

SetLinkVelocity((PhysicsEngine)arg1, (object)arg2, (object)link, (object)velocity) → bool :¶

bool SetLinkVelocity(KinBody::LinkPtr link, const Vector & linearvel, const Vector & angularvel)

Force the body velocity of a link, velocities correspond to the link’s coordinate system origin.

Parameters

link -

link to set velocities.

linearvel -

linear velocity of base link

angularvel -

angular velocity rotation_axis*theta_dot

SetPhysicsOptions((PhysicsEngine)arg1, (int)arg2) → bool :¶

bool SetPhysicsOptions(int physicsoptions)

Set basic physics engine using the PhysicsEngineOptions enum.

SimulateStep((PhysicsEngine)arg1, (float)arg2) → None :¶

void SimulateStep(dReal fTimeElapsed)

dynamically simulate system for fTimeElapsed seconds add torques to the joints of the body. Torques disappear after one timestep of simulation

class openravepy.openravepy_int.PhysicsEngineOptions¶

Bases: Boost.Python.enum

PhysicsEngineOptions

basic options for physics engine

SelfCollisions = openravepy.openravepy_int.PhysicsEngineOptions.SelfCollisions¶

names = {'SelfCollisions': openravepy.openravepy_int.PhysicsEngineOptions.SelfCollisions}¶

values = {1: openravepy.openravepy_int.PhysicsEngineOptions.SelfCollisions}¶

class openravepy.openravepy_int.Planner¶

Bases: openravepy.openravepy_int.Interface

Raises an exception This class cannot be instantiated from Python

GetParameters((Planner)arg1) → PlannerParameters :¶

PlannerParametersConstPtr GetParameters()

return the internal parameters of the planner

InitPlan((Planner)arg1, (Robot)robot, (PlannerParameters)params[, (bool)releasegil]) → bool :¶

bool InitPlan(RobotBasePtr robot, PlannerParametersConstPtr params)

Setup scene, robot, and properties of the plan, and reset all internal structures.

Parameters

robot -

main robot to be used for planning

params -

The parameters of the planner, any class derived from PlannerParameters can be passed. The planner should copy these parameters for future instead of storing the pointer.

InitPlan( (Planner)arg1, (Robot)robot, (str)xmlparams) -> bool :

bool InitPlan(RobotBasePtr robot, std::istream & isParameters)

Setup scene, robot, and properties of the plan, and reset all structures with pparams.

Parameters

robot -

main robot to be used for planning

isParameters -

The serialized form of the parameters. By default, this exists to allow third parties to pass information to planners without excplicitly knowning the format/internal structures used

Return

true if plan is initialized successfully and initial conditions are satisfied.

PlanPath((Planner)arg1, (Trajectory)traj[, (bool)releasegil]) → PlannerStatus :¶

PlannerStatus PlanPath(TrajectoryBasePtr ptraj)

Executes the main planner trying to solve for the goal condition.

Parameters

ptraj -

The output trajectory the robot has to follow in order to successfully complete the plan. If this planner is a path optimizer, the trajectory can be used as an input for generating a smoother path. The trajectory is for the configuration degrees of freedom defined by the planner parameters. Fill ptraj with the trajectory of the planned path that the robot needs to execute

Return

the status that the planner returned in.

class PlannerParameters¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

__init__( (object)arg1) -> None

__init__( (object)arg1, (PlannerParameters)parameters) -> None

SetConfigurationSpecification((PlannerParameters)arg1, (Environment)env, (ConfigurationSpecification)spec) → None¶

SetExtraParameters((PlannerParameters)arg1, (str)extra) → None¶

SetGoalConfig((PlannerParameters)arg1, (object)values) → None :¶

sets PlannerParameters::vgoalconfig

SetInitialConfig((PlannerParameters)arg1, (object)values) → None :¶

sets PlannerParameters::vinitialconfig

SetRobotActiveJoints((PlannerParameters)arg1, (Robot)robot) → None¶

class openravepy.openravepy_int.PlannerAction¶

Bases: Boost.Python.enum

PlannerAction

action to send to the planner while it is planning. This is usually done by the user-specified planner callback function

Interrupt = openravepy.openravepy_int.PlannerAction.Interrupt¶

None = openravepy.openravepy_int.PlannerAction.None¶

ReturnWithAnySolution = openravepy.openravepy_int.PlannerAction.ReturnWithAnySolution¶

names = {'Interrupt': openravepy.openravepy_int.PlannerAction.Interrupt, 'None': openravepy.openravepy_int.PlannerAction.None, 'ReturnWithAnySolution': openravepy.openravepy_int.PlannerAction.ReturnWithAnySolution}¶

values = {0: openravepy.openravepy_int.PlannerAction.None, 1: openravepy.openravepy_int.PlannerAction.Interrupt, 2: openravepy.openravepy_int.PlannerAction.ReturnWithAnySolution}¶

class openravepy.openravepy_int.PlannerProgress¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

class openravepy.openravepy_int.PlannerStatus¶

Bases: Boost.Python.enum

PlannerStatus

the status of the PlanPath method. Used when PlanPath can be called multiple times to resume planning.

Failed = openravepy.openravepy_int.PlannerStatus.Failed¶

HasSolution = openravepy.openravepy_int.PlannerStatus.HasSolution¶

Interrupted = openravepy.openravepy_int.PlannerStatus.Interrupted¶

InterruptedWithSolution = openravepy.openravepy_int.PlannerStatus.InterruptedWithSolution¶

names = {'InterruptedWithSolution': openravepy.openravepy_int.PlannerStatus.InterruptedWithSolution, 'Failed': openravepy.openravepy_int.PlannerStatus.Failed, 'Interrupted': openravepy.openravepy_int.PlannerStatus.Interrupted, 'HasSolution': openravepy.openravepy_int.PlannerStatus.HasSolution}¶

values = {0: openravepy.openravepy_int.PlannerStatus.Failed, 1: openravepy.openravepy_int.PlannerStatus.HasSolution, 2: openravepy.openravepy_int.PlannerStatus.Interrupted, 3: openravepy.openravepy_int.PlannerStatus.InterruptedWithSolution}¶

class openravepy.openravepy_int.PluginInfo¶

Bases: Boost.Python.instance

Raises an exception This class cannot be instantiated from Python

interfacenames¶

version¶

openravepy.openravepy_int.RaveClone((Interface)ref, (int)cloningoptions) → Interface :¶

boost::shared_ptr< T > RaveClone(boost::shared_ptr< T const > preference, int cloningoptions)

returned a fully cloned interface

openravepy.openravepy_int.RaveCreateCollisionChecker((Environment)env, (str)name) → CollisionChecker :¶

OPENRAVE_API CollisionCheckerBasePtr RaveCreateCollisionChecker(EnvironmentBasePtr penv, const std::string & name)

openravepy.openravepy_int.RaveCreateController((Environment)env, (str)name) → Controller :¶

OPENRAVE_API ControllerBasePtr RaveCreateController(EnvironmentBasePtr penv, const std::string & name)

openravepy.openravepy_int.RaveCreateIkSolver((Environment)env, (str)name) → IkSolver :¶

OPENRAVE_API IkSolverBasePtr RaveCreateIkSolver(EnvironmentBasePtr penv, const std::string & name)

openravepy.openravepy_int.RaveCreateInterface((Environment)env, (InterfaceType)type, (str)name) → Interface :¶

OPENRAVE_API InterfaceBasePtr RaveCreateInterface(EnvironmentBasePtr penv, InterfaceType type, const std::string & interfacename)

openravepy.openravepy_int.RaveCreateKinBody((Environment)env, (str)name) → KinBody :¶

OPENRAVE_API KinBodyPtr RaveCreateKinBody(EnvironmentBasePtr penv, const std::string & name = “” )

openravepy.openravepy_int.RaveCreateModule((Environment)env, (str)name) → Module :¶

OPENRAVE_API ModuleBasePtr RaveCreateModule(EnvironmentBasePtr penv, const std::string & name)

openravepy.openravepy_int.RaveCreatePhysicsEngine((Environment)env, (str)name) → PhysicsEngine :¶

OPENRAVE_API PhysicsEngineBasePtr RaveCreatePhysicsEngine(EnvironmentBasePtr penv, const std::string & name)

openravepy.openravepy_int.RaveCreatePlanner((Environment)env, (str)name) → Planner :¶

OPENRAVE_API PlannerBasePtr RaveCreatePlanner(EnvironmentBasePtr penv, const std::string & name)

openravepy.openravepy_int.RaveCreateProblem((Environment)env, (str)name) → Module :¶

OPENRAVE_API ModuleBasePtr RaveCreateModule(EnvironmentBasePtr penv, const std::string & name)

openravepy.openravepy_int.RaveCreateProblemInstance((Environment)env, (str)name) → Module :¶

OPENRAVE_API ModuleBasePtr RaveCreateModule(EnvironmentBasePtr penv, const std::string & name)

openravepy.openravepy_int.RaveCreateRobot((Environment)env, (str)name) → Robot :¶

OPENRAVE_API RobotBasePtr RaveCreateRobot(EnvironmentBasePtr penv, const std::string & name = “” )

openravepy.openravepy_int.RaveCreateSensor((Environment)env, (str)name) → Sensor :¶

OPENRAVE_API SensorBasePtr RaveCreateSensor(EnvironmentBasePtr penv, const std::string & name)

openravepy.openravepy_int.RaveCreateSensorSystem((Environment)env, (str)name) → SensorSystem :¶

OPENRAVE_API SensorSystemBasePtr RaveCreateSensorSystem(EnvironmentBasePtr penv, const std::string & name)

openravepy.openravepy_int.RaveCreateSpaceSampler((Environment)env, (str)name) → SpaceSampler :¶

OPENRAVE_API SpaceSamplerBasePtr RaveCreateSpaceSampler(EnvironmentBasePtr penv, const std::string & name)

openravepy.openravepy_int.RaveCreateTrajectory((Environment)env, (str)name) → Trajectory :¶

OPENRAVE_API TrajectoryBasePtr RaveCreateTrajectory(EnvironmentBasePtr penv, const std::string & name = “” )

Return an empty trajectory instance.

openravepy.openravepy_int.RaveCreateViewer((Environment)env, (str)name) → Viewer :¶

OPENRAVE_API ViewerBasePtr RaveCreateViewer(EnvironmentBasePtr penv, const std::string & name)

openravepy.openravepy_int.RaveDestroy() → None :¶

OPENRAVE_API void RaveDestroy()

Destroys the entire OpenRAVE state and all loaded environments.

This functions should be always called before program shutdown in order to assure all resources are relased appropriately.

openravepy.openravepy_int.RaveFindDatabaseFile((str)arg1, (bool)arg2) → str :¶

OPENRAVE_API std::string RaveFindDatabaseFile(const std::string & filename, bool bRead = true )

Searches for a filename in the database and returns a full path/URL to it.

Parameters

filename -

the relative filename in the database

bRead -

if true will only return a file if it exists. If false, will return the filename of the first valid database directory.

Return

a non-empty string if a file could be found.

openravepy.openravepy_int.RaveFindLocalFile((str)filename[, (str)curdir]) → str¶

openravepy.openravepy_int.RaveGetAffineConfigurationSpecification((int)affinedofs[, (KinBody)body[, (str)interpolation]]) → ConfigurationSpecification :¶

OPENRAVE_API ConfigurationSpecification RaveGetAffineConfigurationSpecification(int affinedofs, KinBodyConstPtr pbody = KinBodyConstPtr () , const std::string & interpolation = “” )

openravepy.openravepy_int.RaveGetAffineDOF((int)affinedofs) → int :¶

OPENRAVE_API int RaveGetAffineDOF(int affinedofs)

Returns the degrees of freedom needed to represent all the values in the affine dof mask.

Exceptions

openrave_exception -

throws if

openravepy.openravepy_int.RaveGetAffineDOFFromIndex((int)affinedofs, (int)index) → DOFAffine :¶

OPENRAVE_API DOFAffine RaveGetAffineDOFFromIndex(int affinedofs, int index)

Given a mask of affine dofs and an index into the array, returns the affine dof that is being referenced.

Parameters

affinedofs -

a mask of DOFAffine values

index -

an index into the affine dof array Exceptions

openrave_exception -

throws if dof if index is out of bounds

openravepy.openravepy_int.RaveGetAffineDOFValuesFromTransform((object)transform, (int)affinedofs[, (object)rotationaxis]) → object :¶

OPENRAVE_API void RaveGetAffineDOFValuesFromTransform(std::vector< dReal >::iterator itvalues, const Transform & t, int affinedofs, const Vector & vActvAffineRotationAxis = Vector (0, 0, 1) )

Converts the transformation matrix into the specified affine values format.

Parameters

itvalues -

an iterator to the vector to write the values to. Will write exactly RaveGetAffineDOF(affinedofs) values.

the -

affine transformation to convert

affinedofs -

the affine format to output values in

vActvAffineRotationAxis -

optional rotation axis if affinedofs specified DOF_RotationAxis

openravepy.openravepy_int.RaveGetDataAccess() → int :¶

OPENRAVE_API int RaveGetDataAccess()

Returns the acess options set.

See

RaveSetDataAccess

openravepy.openravepy_int.RaveGetDebugLevel() → int :¶

OPENRAVE_API int RaveGetDebugLevel()

Returns the openrave debug level.

openravepy.openravepy_int.RaveGetEnvironment((int)arg1) → Environment :¶

OPENRAVE_API EnvironmentBasePtr RaveGetEnvironment(int id)

get the environment from its unique id

Parameters

id -

the unique environment id returned by RaveGetEnvironmentId

openravepy.openravepy_int.RaveGetEnvironmentId((Environment)arg1) → int :¶

OPENRAVE_API int RaveGetEnvironmentId(EnvironmentBasePtr penv)

return the environment’s unique id, returns 0 if environment could not be found or not registered

openravepy.openravepy_int.RaveGetEnvironments() → object :¶

OPENRAVE_API void RaveGetEnvironments(std::list< EnvironmentBasePtr > & listenvironments)

Return all the created OpenRAVE environments.

openravepy.openravepy_int.RaveGetHomeDirectory() → str :¶

OPENRAVE_API std::string RaveGetHomeDirectory()

Returns the openrave home directory where settings, cache, and other files are stored.

On Linux/Unix systems, this is usually $HOME/.openrave, on Windows this is $HOMEPATH/.openrave

openravepy.openravepy_int.RaveGetIkTypeFromUniqueId((int)uniqueid) → IkParameterizationType :¶

OPENRAVE_API IkParameterizationType RaveGetIkTypeFromUniqueId(int uniqueid)

returns the IkParameterizationType given the unique id detmerined b IKP_UniqueIdMask

openravepy.openravepy_int.RaveGetIndexFromAffineDOF((int)affinedofs, (DOFAffine)dof) → int :¶

OPENRAVE_API int RaveGetIndexFromAffineDOF(int affinedofs, DOFAffine dof)

Given a mask of affine dofs and a dof inside that mask, returns the index where the value could be found.

Parameters

affinedofs -

a mask of DOFAffine values

dof -

a set of values inside affinedofs, the index of the first value is returned Exceptions

openrave_exception -

throws if dof is not present in affinedofs

openravepy.openravepy_int.RaveGetLoadedInterfaces() → object :¶

OPENRAVE_API void RaveGetLoadedInterfaces(std::map< InterfaceType, std::vector< std::string > > & interfacenames)

Get a list of all the loaded interfaces.

openravepy.openravepy_int.RaveGetPluginInfo() → object :¶

OPENRAVE_API void RaveGetPluginInfo(std::list< std::pair< std::string, PLUGININFO > > & plugins)

Get all the loaded plugins and the interfaces they support.

Parameters

plugins -

A list of plugins. Each entry has the plugin name and the interfaces it supports

openravepy.openravepy_int.RaveGlobalState() → UserData :¶

OPENRAVE_API UserDataPtr RaveGlobalState()

A pointer to the global openrave state.

Return

a managed pointer to the state.

openravepy.openravepy_int.RaveHasInterface((InterfaceType)type, (str)name) → bool :¶

OPENRAVE_API bool RaveHasInterface(InterfaceType type, const std::string & interfacename)

Returns true if interface can be created, otherwise false.

openravepy.openravepy_int.RaveInitialize([(bool)load_all_plugins[, (object)level]]) → int :¶

OPENRAVE_API int RaveInitialize(bool bLoadAllPlugins = true , int level = Level_Info )

Explicitly initializes the global OpenRAVE state (optional).

Parameters

bLoadAllPlugins -

If true will load all the openrave plugins automatically that can be found in the OPENRAVE_PLUGINS environment path Optional function to initialize openrave plugins, logging, and read OPENRAVE_* environment variables. Although environment creation will automatically make sure this function is called, users might want explicit control of when this happens. Will not do anything if OpenRAVE runtime is already initialized. If OPENRAVE_* environment variables must be re-read, first call RaveDestroy.

Return

0 if successful, otherwise an error code

openravepy.openravepy_int.RaveLoadPlugin((str)filename) → bool¶

openravepy.openravepy_int.RaveLog((str)log, (int)level) → None :¶

Send a log to the openrave system with excplicit level

openravepy.openravepy_int.RaveLogDebug((str)log) → None :¶

Send a debug log to the openrave system

openravepy.openravepy_int.RaveLogError((str)log) → None :¶

Send an error log to the openrave system

openravepy.openravepy_int.RaveLogFatal((str)log) → None :¶

Send a fatal log to the openrave system

openravepy.openravepy_int.RaveLogInfo((str)log) → None :¶

Send an info log to the openrave system

openravepy.openravepy_int.RaveLogVerbose((str)log) → None :¶

Send a verbose log to the openrave system

openravepy.openravepy_int.RaveLogWarn((str)log) → None :¶

Send a warn log to the openrave system

openravepy.openravepy_int.RaveReloadPlugins() → None :¶

OPENRAVE_API void RaveReloadPlugins()

Reloads all the plugins.

The interfaces currently created remain will continue using the old plugins, so this function is safe in that plugins currently loaded remain loaded until the last interface that uses them is released.

openravepy.openravepy_int.RaveSetDataAccess((object)accessoptions) → None :¶

OPENRAVE_API void RaveSetDataAccess(int accessoptions)

Sets the default data access options for cad resources/robot files.

Parameters

accessoptions -

• if 1 will only allow resources inside directories specified from OPERNAVE_DATA environment variable. This allows reject of full paths from unsecure/unauthenticated resources. Controls how files are processed in functions like RaveFindLocalFile

openravepy.openravepy_int.RaveSetDebugLevel((object)level) → None :¶

OPENRAVE_API void RaveSetDebugLevel(int level)

Sets the global openrave debug level. A combination of DebugLevel.

class openravepy.openravepy_int.Ray¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

__init__( (object)arg1, (object)pos, (object)dir) -> None

dir((Ray)arg1) → object¶

pos((Ray)arg1) → object¶

class openravepy.openravepy_int.Robot¶

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

Raises an exception This class cannot be instantiated from Python

AddManipulator((Robot)arg1, (ManipulatorInfo)manip) → Manipulator :¶

ManipulatorPtr AddManipulator(const ManipulatorInfo & manipinfo)

adds a manipulator the list

Exceptions

openrave_exception -

If there exists a manipulator with the same name, will throw an exception Will copy the information of this manipulator object into a new manipulator and initialize it with the robot. Will change the robot structure hash..

Return

the new manipulator attached to the robot

class AttachedSensor¶

Bases: Boost.Python.instance

Raises an exception This class cannot be instantiated from Python

GetAttachingLink((AttachedSensor)arg1) → object :¶

LinkPtr GetAttachingLink()

GetData((AttachedSensor)arg1) → object :¶

SensorBase::SensorDataPtr GetData()

retrieves the current data from the sensor

GetName((AttachedSensor)arg1) → object :¶

const std::string & GetName()

GetRelativeTransform((AttachedSensor)arg1) → object :¶

Transform GetRelativeTransform()

GetRobot((AttachedSensor)arg1) → Robot :¶

RobotBasePtr GetRobot()

GetSensor((AttachedSensor)arg1) → object :¶

SensorBasePtr GetSensor()

GetStructureHash((AttachedSensor)arg1) → str :¶

const std::string & GetStructureHash()

Return

hash of the sensor definition

GetTransform((AttachedSensor)arg1) → object :¶

Transform GetTransform()

SetRelativeTransform((AttachedSensor)arg1, (object)transform) → None :¶

void SetRelativeTransform(const Transform & t)

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

void CalculateActiveAngularVelocityJacobian(int index, std::vector< dReal > & jacobian)

Calculates the angular velocity jacobian of a specified link about the axes of world coordinates.Parameters

index -

of the link that the rotation is attached to

mjacobian -

3x(num ACTIVE DOF) matrix

Robot.CalculateActiveJacobian((Robot)arg1, (int)linkindex, (object)offset) → object :¶

void CalculateActiveJacobian(int index, const Vector & offset, std::vector< dReal > & jacobian)

Calculates the translation jacobian with respect to a link.

Parameters

mjacobian -

a 3 x ActiveDOF matrix Calculates the partial differentials for the active degrees of freedom that in the path from the root node to _veclinks[index] (doesn’t touch the rest of the values).

Robot.CalculateActiveRotationJacobian((Robot)arg1, (int)linkindex, (object)quat) → object :¶

void CalculateActiveRotationJacobian(int index, const Vector & qInitialRot, std::vector< dReal > & jacobian)

Robot.CreateRobotStateSaver((Robot)arg1[, (object)options]) → StateRestoreContext :¶

Creates an object that can be entered using ‘with’ and returns a RobotStateSaver

class Robot.DOFAffine¶

Bases: Boost.Python.enum

DOFAffine

Selects which DOFs of the affine transformation to include in the active configuration.

NoTransform = openravepy.openravepy_int.DOFAffine.NoTransform¶

Rotation3D = openravepy.openravepy_int.DOFAffine.Rotation3D¶

RotationAxis = openravepy.openravepy_int.DOFAffine.RotationAxis¶

RotationMask = openravepy.openravepy_int.DOFAffine.RotationMask¶

RotationQuat = openravepy.openravepy_int.DOFAffine.RotationQuat¶

Transform = openravepy.openravepy_int.DOFAffine.Transform¶

X = openravepy.openravepy_int.DOFAffine.X¶

Y = openravepy.openravepy_int.DOFAffine.Y¶

Z = openravepy.openravepy_int.DOFAffine.Z¶

names = {'NoTransform': openravepy.openravepy_int.DOFAffine.NoTransform, 'Rotation3D': openravepy.openravepy_int.DOFAffine.Rotation3D, 'RotationQuat': openravepy.openravepy_int.DOFAffine.RotationQuat, 'RotationAxis': openravepy.openravepy_int.DOFAffine.RotationAxis, 'Transform': openravepy.openravepy_int.DOFAffine.Transform, 'RotationMask': openravepy.openravepy_int.DOFAffine.RotationMask, 'Y': openravepy.openravepy_int.DOFAffine.Y, 'X': openravepy.openravepy_int.DOFAffine.X, 'Z': openravepy.openravepy_int.DOFAffine.Z}¶

values = {0: openravepy.openravepy_int.DOFAffine.NoTransform, 1: openravepy.openravepy_int.DOFAffine.X, 2: openravepy.openravepy_int.DOFAffine.Y, 4: openravepy.openravepy_int.DOFAffine.Z, 32: openravepy.openravepy_int.DOFAffine.RotationQuat, 8: openravepy.openravepy_int.DOFAffine.RotationAxis, 39: openravepy.openravepy_int.DOFAffine.Transform, 16: openravepy.openravepy_int.DOFAffine.Rotation3D, 56: openravepy.openravepy_int.DOFAffine.RotationMask}¶

Robot.GetActiveConfigurationSpecification((Robot)arg1[, (str)interpolation]) → object :¶

ConfigurationSpecification GetActiveConfigurationSpecification(const std::string & interpolation = “” )

return a copy of the configuration specification of the active dofs

Note that the return type is by-value, so should not be used in iteration

Robot.GetActiveDOF((Robot)arg1) → int :¶

int GetActiveDOF()

Robot.GetActiveDOFIndices((Robot)arg1) → object :¶

const std::vector< int > & GetActiveDOFIndices()

Return the set of active dof indices of the joints.

Robot.GetActiveDOFLimits((Robot)arg1) → object :¶

void GetActiveDOFLimits(std::vector< dReal > & lower, std::vector< dReal > & upper)

Robot.GetActiveDOFMaxAccel((Robot)arg1) → object :¶

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

Robot.GetActiveDOFMaxVel((Robot)arg1) → object :¶

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

Robot.GetActiveDOFResolutions((Robot)arg1) → object :¶

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

Robot.GetActiveDOFValues((Robot)arg1) → object :¶

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

Robot.GetActiveDOFVelocities((Robot)arg1) → object :¶

void GetActiveDOFVelocities(std::vector< dReal > & velocities)

Robot.GetActiveDOFWeights((Robot)arg1) → object :¶

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

Robot.GetActiveJointIndices((Robot)arg1) → object¶

Robot.GetActiveManipulator((Robot)arg1) → Manipulator :¶

ManipulatorPtr GetActiveManipulator()

Robot.GetActiveManipulatorIndex((Robot)arg1) → int :¶

int GetActiveManipulatorIndex()

Robot.GetAffineDOF((Robot)arg1) → int :¶

int GetAffineDOF()

Robot.GetAffineDOFIndex((Robot)arg1, (DOFAffine)index) → int :¶

int GetAffineDOFIndex(DOFAffine dof)

Robot.GetAffineRotation3DLimits((Robot)arg1) → object :¶

void GetAffineRotation3DLimits(Vector & lower, Vector & upper)

Robot.GetAffineRotation3DMaxVels((Robot)arg1) → object :¶

Vector GetAffineRotation3DMaxVels()

Robot.GetAffineRotation3DResolution((Robot)arg1) → object :¶

Vector GetAffineRotation3DResolution()

Robot.GetAffineRotation3DWeights((Robot)arg1) → object :¶

Vector GetAffineRotation3DWeights()

Robot.GetAffineRotationAxis((Robot)arg1) → object :¶

Vector GetAffineRotationAxis()

Robot.GetAffineRotationAxisLimits((Robot)arg1) → object :¶

void GetAffineRotationAxisLimits(Vector & lower, Vector & upper)

Robot.GetAffineRotationAxisMaxVels((Robot)arg1) → object :¶

Vector GetAffineRotationAxisMaxVels()

Robot.GetAffineRotationAxisResolution((Robot)arg1) → object :¶

Vector GetAffineRotationAxisResolution()

Robot.GetAffineRotationAxisWeights((Robot)arg1) → object :¶

Vector GetAffineRotationAxisWeights()

Robot.GetAffineRotationQuatLimits((Robot)arg1) → object :¶

Vector GetAffineRotationQuatLimits()

gets the quaternion limits

Parameters

quatangle -

quaternion_start * max_angle. acos(q dot quaternion_start) <= max_angle

Robot.GetAffineRotationQuatMaxVels((Robot)arg1) → float :¶

dReal GetAffineRotationQuatMaxVels()

Robot.GetAffineRotationQuatResolution((Robot)arg1) → float :¶

dReal GetAffineRotationQuatResolution()

Robot.GetAffineRotationQuatWeights((Robot)arg1) → float :¶

dReal GetAffineRotationQuatWeights()

Robot.GetAffineTranslationLimits((Robot)arg1) → object :¶

void GetAffineTranslationLimits(Vector & lower, Vector & upper)

Robot.GetAffineTranslationMaxVels((Robot)arg1) → object :¶

Vector GetAffineTranslationMaxVels()

Robot.GetAffineTranslationResolution((Robot)arg1) → object :¶

Vector GetAffineTranslationResolution()

Robot.GetAffineTranslationWeights((Robot)arg1) → object :¶

Vector GetAffineTranslationWeights()

Robot.GetAttachedSensor((Robot)arg1, (str)sensorname) → AttachedSensor :¶

Return the attached sensor whose name matches

Robot.GetAttachedSensors((Robot)arg1) → object :¶

std::vector< AttachedSensorPtr > & GetAttachedSensors()

Robot.GetController((Robot)arg1) → object :¶

ControllerBasePtr GetController()

gets the robot controller

Robot.GetGrabbed((Robot)arg1) → object :¶

void GetGrabbed(std::vector< KinBodyPtr > & vbodies)

gets all grabbed bodies of the robot

Parameters

vbodies -

filled with the grabbed bodies

Robot.GetGrabbedInfo((Robot)arg1) → object¶

Robot.GetManipulator((Robot)arg1, (str)manipname) → Manipulator :¶

Return the manipulator whose name matches

Robot.GetManipulators((Robot)arg1) → object :¶

std::vector< ManipulatorPtr > & GetManipulators()

Returns the manipulators of the robot.

GetManipulators( (Robot)arg1, (str)manipname) -> object :

std::vector< ManipulatorPtr > & GetManipulators()

Returns the manipulators of the robot.

Robot.GetRobotStructureHash((Robot)arg1) → str :¶

const std::string & GetRobotStructureHash()

A md5 hash unique to the particular robot structure that involves manipulation and sensing components The serialization for the attached sensors will not involve any sensor specific properties (since they can change through calibration)

Robot.GetSensor((Robot)arg1, (str)sensorname) → AttachedSensor¶

Robot.GetSensors((Robot)arg1) → object¶

Robot.Grab((Robot)arg1, (KinBody)body) → bool :¶

bool Grab(KinBodyPtr body)

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

Parameters

body -

the body to be grabbed

Return

true if successful and body is grabbed

Grab( (Robot)arg1, (KinBody)body, (object)grablink) -> bool :

bool Grab(KinBodyPtr body, LinkPtr pRobotLinkToGrabWith)

Grab a body with the specified link.

Parameters

body -

the body to be grabbed

pRobotLinkToGrabWith -

the link of this robot that will perform the grab

Return

true if successful and body is grabbed/

Grab( (Robot)arg1, (KinBody)body, (object)grablink, (object)linkstoignore) -> bool :

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

Grab the body with the specified link.

Parameters

body -

the body to be grabbed

pRobotLinkToGrabWith -

the link of this robot that will perform the grab

setRobotLinksToIgnore -

Additional robot link indices that collision checker ignore when checking collisions between the grabbed body and the robot.

Return

true if successful and body is grabbed.

class Robot.GrabbedInfo¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

Robot.Init((Robot)arg1, (object)linkinfos, (object)jointinfos, (object)manipinfos, (object)attachedsensorinfos) → bool¶

Robot.IsGrabbing((Robot)arg1, (KinBody)body) → object :¶

LinkPtr IsGrabbing(KinBodyConstPtr body)

return the robot link that is currently grabbing the body. If the body is not grabbed, will return an empty pointer.

Parameters

body -

the body to check

class Robot.Manipulator¶

Bases: Boost.Python.instance

Raises an exception This class cannot be instantiated from Python

CalculateAngularVelocityJacobian((Manipulator)arg1) → object :¶

void CalculateAngularVelocityJacobian(std::vector< dReal > & jacobian)

computes the angule axis jacobian of the manipulator arm indices.

CalculateJacobian((Manipulator)arg1) → object :¶

void CalculateJacobian(std::vector< dReal > & jacobian)

computes the jacobian of the manipulator arm indices of the current manipulator frame world position.

The manipulator frame is computed from Manipulator::GetTransform()

CalculateRotationJacobian((Manipulator)arg1) → object :¶

void CalculateRotationJacobian(std::vector< dReal > & jacobian)

computes the quaternion jacobian of the manipulator arm indices from the current manipulator frame rotation.

CheckEndEffectorCollision((Manipulator)arg1, (object)transform) → bool :¶

bool CheckEndEffectorCollision(const Transform & tEE, CollisionReportPtr report = CollisionReportPtr () )

Checks collision with only the gripper given its end-effector transform. Ignores disabled links.

Parameters

tEE -

the end effector transform

report -

[optional] collision report

Return

true if a collision occurred

CheckEndEffectorCollision( (Manipulator)arg1, (object)transform, (CollisionReport)report) -> bool :

bool CheckEndEffectorCollision(const Transform & tEE, CollisionReportPtr report = CollisionReportPtr () )

Checks collision with only the gripper given its end-effector transform. Ignores disabled links.

Parameters

tEE -

the end effector transform

report -

[optional] collision report

Return

true if a collision occurred

CheckIndependentCollision((Manipulator)arg1) → bool :¶

bool CheckIndependentCollision(CollisionReportPtr report = CollisionReportPtr () )

Checks collision with the environment with all the independent links of the robot. Ignores disabled links.

Parameters

report -

[optional] collision report

Return

true if a collision occurred

CheckIndependentCollision( (Manipulator)arg1, (CollisionReport)report) -> bool :

bool CheckIndependentCollision(CollisionReportPtr report = CollisionReportPtr () )

Checks collision with the environment with all the independent links of the robot. Ignores disabled links.

Parameters

report -

[optional] collision report

Return

true if a collision occurred

FindIKSolution((Manipulator)arg1, (object)param, (int)filteroptions[, (bool)ikreturn[, (bool)releasegil]]) → object :¶

bool FindIKSolution(const IkParameterization & param, std::vector< dReal > & solution, int filteroptions)

Find a close solution to the current robot’s joint values.

Parameters

param -

The transformation of the end-effector in the global coord system

solution -

Will be of size GetArmIndices().size() and contain the best solution

filteroptions -

A bitmask of IkFilterOptions values controlling what is checked for each ik solution. The function is a wrapper around the IkSolver interface. Note that the solution returned is not guaranteed to be the closest solution. In order to compute that, will have to compute all the ik solutions using FindIKSolutions.

FindIKSolution( (Manipulator)arg1, (object)param, (object)freevalues, (int)filteroptions [, (bool)ikreturn [, (bool)releasegil]]) -> object :

bool FindIKSolution(const IkParameterization & param, const std::vector< dReal > & vFreeParameters, std::vector< dReal > & solution, int filteroptions)

FindIKSolutions((Manipulator)arg1, (object)param, (int)filteroptions[, (bool)ikreturn[, (bool)releasegil]]) → object :¶

bool FindIKSolutions(const IkParameterization & param, std::vector< std::vector< dReal > > & solutions, int filteroptions)

Find all the IK solutions for the given end effector transform.

Parameters

param -

The transformation of the end-effector in the global coord system

solutions -

An array of all solutions, each element in solutions is of size GetArmIndices().size()

filteroptions -

A bitmask of IkFilterOptions values controlling what is checked for each ik solution.

FindIKSolutions( (Manipulator)arg1, (object)param, (object)freevalues, (int)filteroptions [, (bool)ikreturn [, (bool)releasegil]]) -> object :

bool FindIKSolutions(const IkParameterization & param, const std::vector< dReal > & vFreeParameters, std::vector< std::vector< dReal > > & solutions, int filteroptions)

GetArmConfigurationSpecification((Manipulator)arg1[, (str)interpolation]) → object :¶

ConfigurationSpecification GetArmConfigurationSpecification(const std::string & interpolation = “” )

return a copy of the configuration specification of the arm indices

Note that the return type is by-value, so should not be used in iteration

GetArmIndices((Manipulator)arg1) → object :¶

const std::vector< int > & GetArmIndices()

Return the indices of the DOFs of the arm (used for IK, etc).

Usually the DOF indices from pBase to pEndEffector

GetArmJoints((Manipulator)arg1) → object :¶

const std::vector< int > & GetArmIndices()

Return the indices of the DOFs of the arm (used for IK, etc).

Usually the DOF indices from pBase to pEndEffector

GetBase((Manipulator)arg1) → object :¶

LinkPtr GetBase()

the base used for the iksolver

GetChildDOFIndices((Manipulator)arg1) → object :¶

void GetChildDOFIndices(std::vector< int > & vdofndices)

Get all child DOF indices of the manipulator starting at the pEndEffector link.

GetChildJoints((Manipulator)arg1) → object :¶

void GetChildJoints(std::vector< JointPtr > & vjoints)

Get all child joints of the manipulator starting at the pEndEffector link.

GetChildLinks((Manipulator)arg1) → object :¶

void GetChildLinks(std::vector< LinkPtr > & vlinks)

Get all child links of the manipulator starting at pEndEffector link.

The child links do not include the arm links.

GetClosingDirection((Manipulator)arg1) → object :¶

const std::vector< dReal > & GetClosingDirection()

return the normal direction to move joints to ‘close’ the hand

GetDirection((Manipulator)arg1) → object :¶

Vector GetLocalToolDirection()

direction of palm/head/manipulator used for approaching. defined inside the manipulator/grasp coordinate system

GetEndEffector((Manipulator)arg1) → object :¶

LinkPtr GetEndEffector()

the end effector link (used to define workspace distance)

GetEndEffectorTransform((Manipulator)arg1) → object :¶

Transform GetTransform()

Return the transformation of the manipulator frame.

The manipulator frame is defined by the the end effector link position * GetLocalToolTransform() All inverse kinematics and jacobian queries are specifying this frame.

GetFreeParameters((Manipulator)arg1) → object :¶

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

gets the free parameters from the current robot configuration

Parameters

vFreeParameters -

is filled with GetNumFreeParameters() parameters in [0,1] range

Return

true if succeeded

GetGraspTransform((Manipulator)arg1) → object :¶

Transform GetLocalToolTransform()

Return transform with respect to end effector defining the grasp coordinate system.

GetGripperIndices((Manipulator)arg1) → object :¶

const std::vector< int > & GetGripperIndices()

Gripper indices of the joints that the manipulator controls.

GetGripperJoints((Manipulator)arg1) → object :¶

const std::vector< int > & GetGripperIndices()

Gripper indices of the joints that the manipulator controls.

GetIkParameterization((Manipulator)arg1, (object)iktype[, (bool)inworld]) → object :¶

IkParameterization GetIkParameterization(const IkParameterization & ikparam, bool inworld = true )

returns a full parameterization of a given IK type for the current manipulator position using an existing IkParameterization as the seed.

Parameters

ikparam -

The parameterization to use as seed.

inworld -

if true will return the parameterization in the world coordinate system, otherwise in the base link (GetBase()) coordinate system Custom data is copied to the new parameterization. Furthermore, some IK types like Lookat3D and TranslationLocalGlobal6D set constraints in the global coordinate system of the manipulator. Because these values are not stored in manipulator itself, they have to be passed in through an existing IkParameterization. Ideally pluging the returned ik parameterization into FindIkSolution should return the a manipulator configuration such that a new call to GetIkParameterization returns the same values.

IkParameterization GetIkParameterization(IkParameterizationType iktype, bool inworld = true )

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

Parameters

iktype -

the type of parameterization to request

inworld -

if true will return the parameterization in the world coordinate system, otherwise in the base link (GetBase()) coordinate system Ideally pluging the returned ik parameterization into FindIkSolution should return the a manipulator configuration such that a new call to GetIkParameterization returns the same values. In other words:

GetIkSolver((Manipulator)arg1) → object :¶

IkSolverBasePtr GetIkSolver()

Returns the currently set ik solver.

GetIndependentLinks((Manipulator)arg1) → object :¶

void GetIndependentLinks(std::vector< LinkPtr > & vlinks)

Get all links that are independent of the arm and gripper joints.

In other words, returns all links not on the path from the base to the end effector and not children of the end effector. The base and all links rigidly attached to it are also returned.

GetInfo((Manipulator)arg1) → object¶

GetKinematicsStructureHash((Manipulator)arg1) → str :¶

const std::string & GetKinematicsStructureHash()

Return hash of all kinematics information that involves solving the inverse kinematics equations.

This includes joint axes, joint positions, and final grasp transform. Hash is used to cache the solvers.

GetLocalToolDirection((Manipulator)arg1) → object :¶

Vector GetLocalToolDirection()

direction of palm/head/manipulator used for approaching. defined inside the manipulator/grasp coordinate system

GetLocalToolTransform((Manipulator)arg1) → object :¶

Transform GetLocalToolTransform()

Return transform with respect to end effector defining the grasp coordinate system.

GetName((Manipulator)arg1) → object :¶

const std::string & GetName()

GetNumFreeParameters((Manipulator)arg1) → int :¶

int GetNumFreeParameters()

Number of free parameters defining the null solution space.

Each parameter is always in the range of [0,1].

GetPalmDirection((Manipulator)arg1) → object :¶

Vector GetLocalToolDirection()

direction of palm/head/manipulator used for approaching. defined inside the manipulator/grasp coordinate system

GetRobot((Manipulator)arg1) → Robot :¶

RobotBasePtr GetRobot()

GetStructureHash((Manipulator)arg1) → str :¶

const std::string & GetStructureHash()

Return hash of just the manipulator definition.

GetTransform((Manipulator)arg1) → object :¶

Transform GetTransform()

Return the transformation of the manipulator frame.

The manipulator frame is defined by the the end effector link position * GetLocalToolTransform() All inverse kinematics and jacobian queries are specifying this frame.

GetVelocity((Manipulator)arg1) → object :¶

std::pair< Vector , Vector > GetVelocity()

return the linear/angular velocity of the manipulator coordinate system

IsChildLink((Manipulator)arg1, (object)arg2) → bool :¶

bool IsChildLink(LinkConstPtr plink)

returns true if a link is part of the child links of the manipulator.

The child links do not include the arm links.

IsGrabbing((Manipulator)arg1, (KinBody)body) → bool :¶

bool IsGrabbing(KinBodyConstPtr body)

Checks collision with a target body and all the independent links of the robot. Ignores disabled links.

Parameters

the -

body to check the independent links with

report -

[optional] collision report

Return

true if a collision occurredreturn true if the body is being grabbed by any link on this manipulator

SetIKSolver((Manipulator)arg1, (IkSolver)arg2) → bool :¶

bool SetIkSolver(IkSolverBasePtr iksolver)

Sets the ik solver and initializes it with the current manipulator.

Due to complications with translation,rotation,direction,and ray ik, the ik solver should take into account the grasp transform (_info._tLocalTool) internally. The actual ik primitives are transformed into the base frame only.

SetIkSolver((Manipulator)arg1, (IkSolver)arg2) → bool :¶

bool SetIkSolver(IkSolverBasePtr iksolver)

Sets the ik solver and initializes it with the current manipulator.

Due to complications with translation,rotation,direction,and ray ik, the ik solver should take into account the grasp transform (_info._tLocalTool) internally. The actual ik primitives are transformed into the base frame only.

SetLocalToolTransform((Manipulator)arg1, (object)arg2) → None :¶

void SetLocalToolTransform(const Transform & t)

Sets the local tool transform with respect to the end effector.

Because this call will change manipulator hash, it resets the loaded IK and sets the Prop_RobotManipulatorTool message.

SetName((Manipulator)arg1, (str)name) → None :¶

void SetName(const std::string & name)

new name for manipulator

Exceptions

openrave_exception -

if name is already used in another manipulator

class Robot.ManipulatorInfo¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

Robot.RegrabAll((Robot)arg1) → None :¶

void RegrabAll()

Releases and grabs all bodies, has the effect of recalculating all the initial collision with the bodies.

This has the effect of resetting the current collisions any grabbed body makes with the robot into an ignore list.

Robot.Release((Robot)arg1, (KinBody)body) → None :¶

void Release(KinBodyPtr body)

Release the body if grabbed.

Parameters

body -

body to release

Robot.ReleaseAllGrabbed((Robot)arg1) → None :¶

void ReleaseAllGrabbed()

Release all grabbed bodies.

release all bodies

Robot.RemoveManipulator((Robot)arg1, (Manipulator)manip) → None :¶

void RemoveManipulator(ManipulatorPtr manip)

removes a manipulator from the robot list.

Will change the robot structure hash.. if the active manipulator is set to this manipulator, it will be set to None afterwards

Robot.ResetGrabbed((Robot)arg1, (object)grabbedinfos) → None¶

class Robot.RobotStateSaver¶

Bases: Boost.Python.instance

__init__( (object)arg1, (Robot)robot) -> None

__init__( (object)arg1, (Robot)robot, (object)options) -> None

GetBody((RobotStateSaver)arg1) → object¶

Release((RobotStateSaver)arg1) → None¶

Restore((RobotStateSaver)arg1[, (Robot)body]) → None¶

Robot.SetActiveDOFValues((Robot)arg1, (object)values[, (int)checklimits]) → None :¶

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

Robot.SetActiveDOFVelocities((Robot)arg1, (object)arg2) → None :¶

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

Robot.SetActiveDOFs((Robot)arg1, (object)dofindices) → None :¶

void SetActiveDOFs(const std::vector< int > & dofindices, int affine = OpenRAVE::DOF_NoTransform )

Set the joint indices and affine transformation dofs that the planner should use. If DOF_RotationAxis is specified, the previously set axis is used.

Parameters

dofindices -

the indices of the original degrees of freedom to use.

affine -

A bitmask of DOFAffine values

SetActiveDOFs( (Robot)arg1, (object)dofindices, (int)affine) -> None :

void SetActiveDOFs(const std::vector< int > & dofindices, int affine = OpenRAVE::DOF_NoTransform )

Set the joint indices and affine transformation dofs that the planner should use. If DOF_RotationAxis is specified, the previously set axis is used.

Parameters

dofindices -

the indices of the original degrees of freedom to use.

affine -

A bitmask of DOFAffine values

SetActiveDOFs( (Robot)arg1, (object)dofindices, (int)affine, (object)rotationaxis) -> None :

void SetActiveDOFs(const std::vector< int > & dofindices, int affine, const Vector & rotationaxis)

Set the joint indices and affine transformation dofs that the planner should use. If DOF_RotationAxis is specified, then rotationaxis is set as the new axis.

Parameters

dofindices -

the indices of the original degrees of freedom to use.

affine -

A bitmask of DOFAffine values

rotationaxis -

if DOF_RotationAxis is specified, pRotationAxis is used as the new axis

Robot.SetActiveManipulator((Robot)arg1, (int)manipindex) → Manipulator :¶

void SetActiveManipulator(int index)

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

void SetActiveManipulator(const std::string & manipname)

sets the active manipulator of the robot

Parameters

manipname -

manipulator name Exceptions

openrave_exception -

if manipulator not present, will throw an exception

SetActiveManipulator( (Robot)arg1, (Manipulator)manip) -> Manipulator :

Set the active manipulator given a pointer

Robot.SetAffineRotation3DLimits((Robot)arg1, (object)lower, (object)upper) → None :¶

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

Robot.SetAffineRotation3DMaxVels((Robot)arg1, (object)velocity) → None :¶

void SetAffineRotation3DMaxVels(const Vector & vels)

Robot.SetAffineRotation3DResolution((Robot)arg1, (object)resolution) → None :¶

void SetAffineRotation3DResolution(const Vector & resolution)

Robot.SetAffineRotation3DWeights((Robot)arg1, (object)weights) → None :¶

void SetAffineRotation3DWeights(const Vector & weights)

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

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

Robot.SetAffineRotationAxisMaxVels((Robot)arg1, (object)velocity) → None :¶

void SetAffineRotationAxisMaxVels(const Vector & vels)

Robot.SetAffineRotationAxisResolution((Robot)arg1, (object)resolution) → None :¶

void SetAffineRotationAxisResolution(const Vector & resolution)

Robot.SetAffineRotationAxisWeights((Robot)arg1, (object)weights) → None :¶

void SetAffineRotationAxisWeights(const Vector & weights)

Robot.SetAffineRotationQuatLimits((Robot)arg1, (object)quatangle) → None :¶

void SetAffineRotationQuatLimits(const Vector & quatangle)

sets the quaternion limits using a starting rotation and the max angle deviation from it.

Parameters

quatangle -

quaternion_start * max_angle. acos(q dot quaternion_start) <= max_angle. If max_angle is 0, then will take the current transform of the robot

Robot.SetAffineRotationQuatMaxVels((Robot)arg1, (float)velocity) → None :¶

void SetAffineRotationQuatMaxVels(dReal vels)

Robot.SetAffineRotationQuatResolution((Robot)arg1, (float)resolution) → None :¶

void SetAffineRotationQuatResolution(dReal resolution)

Robot.SetAffineRotationQuatWeights((Robot)arg1, (float)weights) → None :¶

void SetAffineRotationQuatWeights(dReal weights)

Robot.SetAffineTranslationLimits((Robot)arg1, (object)lower, (object)upper) → None :¶

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

Robot.SetAffineTranslationMaxVels((Robot)lower, (object)upper) → None :¶

void SetAffineTranslationMaxVels(const Vector & vels)

Robot.SetAffineTranslationResolution((Robot)arg1, (object)resolution) → None :¶

void SetAffineTranslationResolution(const Vector & resolution)

Robot.SetAffineTranslationWeights((Robot)arg1, (object)weights) → None :¶

void SetAffineTranslationWeights(const Vector & weights)

Robot.SetController((Robot)arg1, (Controller)arg2, (str)arg3) → bool :¶

bool SetController(ControllerBasePtr controller, const std::vector< int > & dofindices, int nControlTransformation)

set a controller for a robot

Parameters

pController -

• if NULL, sets the controller of this robot to NULL. otherwise attemps to set the controller to this robot.

args -

• the argument list to pass when initializing the controller

SetController( (Robot)arg1, (Controller)robot, (object)dofindices, (int)controltransform) -> bool :

bool SetController(ControllerBasePtr controller, const std::vector< int > & dofindices, int nControlTransformation)

set a controller for a robot

Parameters

pController -

• if NULL, sets the controller of this robot to NULL. otherwise attemps to set the controller to this robot.

args -

• the argument list to pass when initializing the controller

SetController( (Robot)arg1, (Controller)arg2) -> bool :

bool SetController(ControllerBasePtr controller, const std::vector< int > & dofindices, int nControlTransformation)

set a controller for a robot

Parameters

pController -

• if NULL, sets the controller of this robot to NULL. otherwise attemps to set the controller to this robot.

args -

• the argument list to pass when initializing the controller

Robot.SubtractActiveDOFValues((Robot)arg1, (object)values0, (object)values1) → object :¶

void SubtractActiveDOFValues(std::vector< dReal > & q1, const std::vector< dReal > & q2)

computes the configuration difference q1-q2 and stores it in q1. Takes into account joint limits and circular joints

Robot.WaitForController((Robot)arg1, (float)timeout) → bool :¶

Wait until the robot controller is done

class openravepy.openravepy_int.SampleDataType¶

Bases: Boost.Python.enum

SampleDataType

Real = openravepy.openravepy_int.SampleDataType.Real¶

Uint32 = openravepy.openravepy_int.SampleDataType.Uint32¶

names = {'Real': openravepy.openravepy_int.SampleDataType.Real, 'Uint32': openravepy.openravepy_int.SampleDataType.Uint32}¶

values = {1: openravepy.openravepy_int.SampleDataType.Real, 2: openravepy.openravepy_int.SampleDataType.Uint32}¶

class openravepy.openravepy_int.Sensor¶

Bases: openravepy.openravepy_int.Interface

Raises an exception This class cannot be instantiated from Python

class ActuatorSensorData¶

Bases: openravepy.openravepy_int.SensorData

Raises an exception This class cannot be instantiated from Python

appliedcurrent¶

maxacceleration¶

maxcurrent¶

maxjerk¶

maxtorque¶

maxvelocity¶

measuredcurrent¶

measuredtemperature¶

nominalcurrent¶

state¶

staticfriction¶

viscousfriction¶

class Sensor.ActuatorState¶

Bases: Boost.Python.enum

ActuatorState

the state of the actuator

Braked = openravepy.openravepy_int.ActuatorState.Braked¶

Idle = openravepy.openravepy_int.ActuatorState.Idle¶

Moving = openravepy.openravepy_int.ActuatorState.Moving¶

Stalled = openravepy.openravepy_int.ActuatorState.Stalled¶

Undefined = openravepy.openravepy_int.ActuatorState.Undefined¶

names = {'Braked': openravepy.openravepy_int.ActuatorState.Braked, 'Idle': openravepy.openravepy_int.ActuatorState.Idle, 'Moving': openravepy.openravepy_int.ActuatorState.Moving, 'Undefined': openravepy.openravepy_int.ActuatorState.Undefined, 'Stalled': openravepy.openravepy_int.ActuatorState.Stalled}¶

values = {0: openravepy.openravepy_int.ActuatorState.Undefined, 1: openravepy.openravepy_int.ActuatorState.Idle, 2: openravepy.openravepy_int.ActuatorState.Moving, 3: openravepy.openravepy_int.ActuatorState.Stalled, 4: openravepy.openravepy_int.ActuatorState.Braked}¶

class Sensor.CameraIntrinsics¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

K¶

distortion_coeffs¶

distortion_model¶

focal_length¶

class Sensor.CameraSensorData¶

Bases: openravepy.openravepy_int.SensorData

Raises an exception This class cannot be instantiated from Python

KK¶

imagedata¶

transform¶

Sensor.Configure((Sensor)arg1, (ConfigureCommand)command[, (bool)blocking]) → int :¶

int Configure(ConfigureCommand command, bool blocking = false )

Configures properties of the sensor like power.

Parameters

type -

ConfigureCommand

blocking -

If set to true, makes sure the configuration ends before this function returns.(might cause problems if environment is locked). Exceptions

openrave_exception -

if command doesn’t succeed

class Sensor.ConfigureCommand¶

Bases: Boost.Python.enum

ConfigureCommand

A set of commands used for run-time sensor configuration.

PowerCheck = openravepy.openravepy_int.ConfigureCommand.PowerCheck¶

PowerOff = openravepy.openravepy_int.ConfigureCommand.PowerOff¶

PowerOn = openravepy.openravepy_int.ConfigureCommand.PowerOn¶

RenderDataCheck = openravepy.openravepy_int.ConfigureCommand.RenderDataCheck¶

RenderDataOff = openravepy.openravepy_int.ConfigureCommand.RenderDataOff¶

RenderDataOn = openravepy.openravepy_int.ConfigureCommand.RenderDataOn¶

RenderGeometryCheck = openravepy.openravepy_int.ConfigureCommand.RenderGeometryCheck¶

RenderGeometryOff = openravepy.openravepy_int.ConfigureCommand.RenderGeometryOff¶

RenderGeometryOn = openravepy.openravepy_int.ConfigureCommand.RenderGeometryOn¶

names = {'PowerCheck': openravepy.openravepy_int.ConfigureCommand.PowerCheck, 'RenderGeometryCheck': openravepy.openravepy_int.ConfigureCommand.RenderGeometryCheck, 'PowerOff': openravepy.openravepy_int.ConfigureCommand.PowerOff, 'RenderDataCheck': openravepy.openravepy_int.ConfigureCommand.RenderDataCheck, 'RenderDataOff': openravepy.openravepy_int.ConfigureCommand.RenderDataOff, 'RenderGeometryOn': openravepy.openravepy_int.ConfigureCommand.RenderGeometryOn, 'RenderGeometryOff': openravepy.openravepy_int.ConfigureCommand.RenderGeometryOff, 'RenderDataOn': openravepy.openravepy_int.ConfigureCommand.RenderDataOn, 'PowerOn': openravepy.openravepy_int.ConfigureCommand.PowerOn}¶

values = {32: openravepy.openravepy_int.ConfigureCommand.RenderDataOn, 33: openravepy.openravepy_int.ConfigureCommand.RenderDataOff, 35: openravepy.openravepy_int.ConfigureCommand.RenderDataCheck, 49: openravepy.openravepy_int.ConfigureCommand.RenderGeometryOff, 48: openravepy.openravepy_int.ConfigureCommand.RenderGeometryOn, 50: openravepy.openravepy_int.ConfigureCommand.RenderGeometryCheck, 16: openravepy.openravepy_int.ConfigureCommand.PowerOn, 17: openravepy.openravepy_int.ConfigureCommand.PowerOff, 18: openravepy.openravepy_int.ConfigureCommand.PowerCheck}¶

class Sensor.Force6DSensorData¶

Bases: openravepy.openravepy_int.SensorData

Raises an exception This class cannot be instantiated from Python

force¶

torque¶

Sensor.GetName((Sensor)arg1) → object :¶

const std::string & GetName()

Return

the name of the sensor

Sensor.GetSensorData((Sensor)arg1) → SensorData :¶

bool GetSensorData(SensorDataPtr psensordata)

Copy the most recent published data of the sensor given the type.

Parameters

psensordata -

A pointer to SensorData returned from CreateSensorData, the plugin will use psensordata->GetType() in order to return the correctly supported type. Once GetSensorData returns, the caller has full unrestricted access to the data. This method is thread safe.

GetSensorData( (Sensor)arg1, (Type)arg2) -> SensorData :

bool GetSensorData(SensorDataPtr psensordata)

Copy the most recent published data of the sensor given the type.

Parameters

psensordata -

A pointer to SensorData returned from CreateSensorData, the plugin will use psensordata->GetType() in order to return the correctly supported type. Once GetSensorData returns, the caller has full unrestricted access to the data. This method is thread safe.

Sensor.GetSensorGeometry((Sensor)arg1, (Type)arg2) → SensorData :¶

SensorGeometryPtr GetSensorGeometry(SensorType type = ST_Invalid )

Returns the sensor geometry. This method is thread safe.

Parameters

type -

the requested sensor type to create. A sensor can support many types. If type is ST_Invalid, then returns a data structure

Return

sensor geometry pointer, use delete to destroy it

Sensor.GetTransform((Sensor)arg1) → object :¶

Transform GetTransform()

the position of the sensor in the world coordinate system

class Sensor.IMUSensorData¶

Bases: openravepy.openravepy_int.SensorData

Raises an exception This class cannot be instantiated from Python

angular_velocity¶

angular_velocity_covariance¶

linear_acceleration¶

linear_acceleration_covariance¶

rotation¶

rotation_covariance¶

class Sensor.JointEncoderSensorData¶

Bases: openravepy.openravepy_int.SensorData

Raises an exception This class cannot be instantiated from Python

encoderValues¶

encoderVelocity¶

resolution¶

class Sensor.LaserSensorData¶

Bases: openravepy.openravepy_int.SensorData

Raises an exception This class cannot be instantiated from Python

intensity¶

positions¶

ranges¶

class Sensor.OdometrySensorData¶

Bases: openravepy.openravepy_int.SensorData

Raises an exception This class cannot be instantiated from Python

angular_velocity¶

linear_velocity¶

pose¶

pose_covariance¶

targetid¶

velocity_covariance¶

class Sensor.SensorData¶

Bases: Boost.Python.instance

Raises an exception This class cannot be instantiated from Python

stamp¶

type¶

Sensor.SetTransform((Sensor)arg1, (object)arg2) → None :¶

void SetTransform(const Transform & trans)

Set the transform of a sensor (global coordinate system).

Parameters

trans -

• The transform defining the frame of the sensor. Sensors attached to the robot have their transforms automatically set every time the robot is moved

Sensor.Supports((Sensor)arg1, (Type)arg2) → bool :¶

bool Supports(SensorType type)

returns true if sensor supports a particular sensor type

class Sensor.TactileSensorData¶

Bases: openravepy.openravepy_int.SensorData

Raises an exception This class cannot be instantiated from Python

force_covariance¶

forces¶

positions¶

thickness¶

class Sensor.Type¶

Bases: Boost.Python.enum

SensorType

Actuator = openravepy.openravepy_int.Type.Actuator¶

Camera = openravepy.openravepy_int.Type.Camera¶

Force6D = openravepy.openravepy_int.Type.Force6D¶

IMU = openravepy.openravepy_int.Type.IMU¶

Invalid = openravepy.openravepy_int.Type.Invalid¶

JointEncoder = openravepy.openravepy_int.Type.JointEncoder¶

Laser = openravepy.openravepy_int.Type.Laser¶

Odometry = openravepy.openravepy_int.Type.Odometry¶

Tactile = openravepy.openravepy_int.Type.Tactile¶

names = {'JointEncoder': openravepy.openravepy_int.Type.JointEncoder, 'Odometry': openravepy.openravepy_int.Type.Odometry, 'Laser': openravepy.openravepy_int.Type.Laser, 'Invalid': openravepy.openravepy_int.Type.Invalid, 'Camera': openravepy.openravepy_int.Type.Camera, 'IMU': openravepy.openravepy_int.Type.IMU, 'Actuator': openravepy.openravepy_int.Type.Actuator, 'Force6D': openravepy.openravepy_int.Type.Force6D, 'Tactile': openravepy.openravepy_int.Type.Tactile}¶

values = {0: openravepy.openravepy_int.Type.Invalid, 1: openravepy.openravepy_int.Type.Laser, 2: openravepy.openravepy_int.Type.Camera, 3: openravepy.openravepy_int.Type.JointEncoder, 4: openravepy.openravepy_int.Type.Force6D, 5: openravepy.openravepy_int.Type.IMU, 6: openravepy.openravepy_int.Type.Odometry, 7: openravepy.openravepy_int.Type.Tactile, 8: openravepy.openravepy_int.Type.Actuator}¶

class openravepy.openravepy_int.SensorSystem¶

Bases: openravepy.openravepy_int.Interface

Raises an exception This class cannot be instantiated from Python

class openravepy.openravepy_int.SerializableData¶

Bases: openravepy.openravepy_int.UserData

Raises an exception This class cannot be instantiated from Python

Deserialize((SerializableData)arg1, (str)data) → None¶

Serialize((SerializableData)arg1, (int)options) → object¶

class openravepy.openravepy_int.SerializationOptions¶

Bases: Boost.Python.enum

SerializationOptions

serialization options for interfaces

BodyState = openravepy.openravepy_int.SerializationOptions.BodyState¶

Dynamics = openravepy.openravepy_int.SerializationOptions.Dynamics¶

Geometry = openravepy.openravepy_int.SerializationOptions.Geometry¶

Kinematics = openravepy.openravepy_int.SerializationOptions.Kinematics¶

NamesAndFiles = openravepy.openravepy_int.SerializationOptions.NamesAndFiles¶

RobotManipulators = openravepy.openravepy_int.SerializationOptions.RobotManipulators¶

RobotSensors = openravepy.openravepy_int.SerializationOptions.RobotSensors¶

names = {'NamesAndFiles': openravepy.openravepy_int.SerializationOptions.NamesAndFiles, 'BodyState': openravepy.openravepy_int.SerializationOptions.BodyState, 'Geometry': openravepy.openravepy_int.SerializationOptions.Geometry, 'RobotManipulators': openravepy.openravepy_int.SerializationOptions.RobotManipulators, 'Kinematics': openravepy.openravepy_int.SerializationOptions.Kinematics, 'RobotSensors': openravepy.openravepy_int.SerializationOptions.RobotSensors, 'Dynamics': openravepy.openravepy_int.SerializationOptions.Dynamics}¶

values = {32: openravepy.openravepy_int.SerializationOptions.RobotSensors, 1: openravepy.openravepy_int.SerializationOptions.Kinematics, 2: openravepy.openravepy_int.SerializationOptions.Dynamics, 4: openravepy.openravepy_int.SerializationOptions.BodyState, 8: openravepy.openravepy_int.SerializationOptions.NamesAndFiles, 64: openravepy.openravepy_int.SerializationOptions.Geometry, 16: openravepy.openravepy_int.SerializationOptions.RobotManipulators}¶

class openravepy.openravepy_int.SpaceSampler¶

Bases: openravepy.openravepy_int.Interface

Raises an exception This class cannot be instantiated from Python

GetDOF((SpaceSampler)arg1) → int :¶

int GetDOF()

returns the degrees of freedom of the sampling space

GetLimits((SpaceSampler)arg1, (SampleDataType)seed) → object :¶

void GetLimits(std::vector< dReal > & vLowerLimit, std::vector< dReal > & vUpperLimit)

returns the minimum and maximum values returned for each dimension (size is GetNumberOfValues())

By default the limits should be in [0,1]^N.

GetNumberOfValues((SpaceSampler)seed) → int :¶

int GetNumberOfValues()

Dimension of the return samples.

Number of values used to represent the parameterization of the space (>= dof). For example, let a quaternion describe a 3D rotation. The DOF of the space is 3, while the dimension of the returned samples is 4.

SampleComplete((SpaceSampler)arg1, (SampleDataType)arg2, (int)num, (Interval)interval) → object :¶

void SampleComplete(std::vector< dReal > & samples, size_t num, IntervalType interval = IT_Closed )

returns N samples that best approximate the entire sampling space.

The sampler can fail by returning an array of size 0.

SampleComplete( (SpaceSampler)arg1, (SampleDataType)arg2, (int)num) -> object :

void SampleComplete(std::vector< uint32_t > & samples, size_t num)

returns N samples that best approximate the entire sampling space.

The sampler can fail by returning an array of size 0.

SampleSequence((SpaceSampler)arg1, (SampleDataType)arg2, (int)num, (Interval)interval) → object :¶

void SampleSequence(std::vector< dReal > & samples, size_t num = 1 , IntervalType interval = IT_Closed )

sequentially sampling returning the next ‘num’ samples

Parameters

sample -

the values of the samples. This is a num*GetNumberOfValues() array.

num -

number of samples to return

interval -

the sampling intervel for each of the dimensions. The sampler can fail by returning an array of size 0.

SampleSequence( (SpaceSampler)arg1, (SampleDataType)arg2, (int)num) -> object :

void SampleSequence(std::vector< uint32_t > & sample, size_t num = 1 )

sequentially sampling returning the next ‘num’ samples

Parameters

sample -

the values of the samples. This is a num*GetNumberOfValues() array.

num -

number of samples to return The sampler can fail by returning an array of size 0.

SampleSequenceOneReal((SpaceSampler)arg1[, (Interval)interval]) → float¶

SampleSequenceOneUInt32((SpaceSampler)arg1) → int¶

SetSeed((SpaceSampler)arg1, (int)seed) → None :¶

void SetSeed(uint32_t seed)

sets a new seed. For sequence samplers, the seed describes the n^th sample to begin at.

SetSpaceDOF((SpaceSampler)arg1, (int)dof) → None :¶

void SetSpaceDOF(int dof)

Sets the degrees of freedom of the space (note this is different from the parameterization dimension)

Supports((SpaceSampler)arg1, (SampleDataType)seed) → bool :¶

bool Supports(SampleDataType type)

class openravepy.openravepy_int.StateRestoreContext¶

Bases: Boost.Python.instance

Raises an exception This class cannot be instantiated from Python

Close((StateRestoreContext)arg1) → None¶

GetBody((StateRestoreContext)arg1) → object¶

Release((StateRestoreContext)arg1) → None¶

Restore((StateRestoreContext)arg1[, (object)body]) → None¶

class openravepy.openravepy_int.Trajectory¶

Bases: openravepy.openravepy_int.Interface

Raises an exception This class cannot be instantiated from Python

GetConfigurationSpecification((Trajectory)arg1) → object :¶

const ConfigurationSpecification & GetConfigurationSpecification()

GetDuration((Trajectory)arg1) → float¶

GetNumWaypoints((Trajectory)arg1) → int :¶

size_t GetNumWaypoints()

return the number of waypoints

GetWaypoint((Trajectory)arg1, (int)index) → object¶

GetWaypoint( (Trajectory)arg1, (int)index, (ConfigurationSpecification)spec) -> object

GetWaypoints((Trajectory)arg1, (int)startindex, (int)endindex) → object¶

GetWaypoints( (Trajectory)arg1, (int)startindex, (int)endindex, (ConfigurationSpecification)spec) -> object

Init((Trajectory)arg1, (ConfigurationSpecification)spec) → None :¶

void Init(const ConfigurationSpecification & spec)

Insert((Trajectory)arg1, (int)index, (object)data) → None :¶

void Insert(size_t index, const std::vector< dReal > & data, bool bOverwrite = false )

Sets/inserts new waypoints in the same configuration specification as the trajectory.

Parameters

index -

The index where to start modifying the trajectory.

data -

The data to insert, can represent multiple consecutive waypoints. data.size()/GetConfigurationSpecification().GetDOF() waypoints are added.

bOverwrite -

If true, will overwrite the waypoints starting at index, and will insert new waypoints only if end of trajectory is reached. If false, will insert the points before index: a 0 index inserts the new data in the beginning, a GetNumWaypoints() index inserts the new data at the end.

Insert( (Trajectory)arg1, (int)index, (object)data, (bool)overwrite) -> None :

void Insert(size_t index, const std::vector< dReal > & data, bool bOverwrite = false )

Sets/inserts new waypoints in the same configuration specification as the trajectory.

Parameters

index -

The index where to start modifying the trajectory.

data -

The data to insert, can represent multiple consecutive waypoints. data.size()/GetConfigurationSpecification().GetDOF() waypoints are added.

bOverwrite -

If true, will overwrite the waypoints starting at index, and will insert new waypoints only if end of trajectory is reached. If false, will insert the points before index: a 0 index inserts the new data in the beginning, a GetNumWaypoints() index inserts the new data at the end.

Insert( (Trajectory)arg1, (int)index, (object)data, (ConfigurationSpecification)spec) -> None :

void Insert(size_t index, const std::vector< dReal > & data, const ConfigurationSpecification & spec, bool bOverwrite = false )

Sets/inserts new waypoints in a configuration specification.

Parameters

index -

The index where to start modifying the trajectory.

data -

The data to insert, can represent multiple consecutive waypoints. data.size()/GetConfigurationSpecification().GetDOF() waypoints are added.

spec -

the specification in which the input data come in. Depending on what data is offered, some values of this trajectory’s specification might not be initialized.

bOverwrite -

If true, will overwrite the waypoints starting at index, and will insert new waypoints only if end of trajectory is reached; if the input spec does not overwrite all the data of the trjectory spec, then the original trajectory data will not be overwritten. If false, will insert the points before index: a 0 index inserts the new data in the beginning, a GetNumWaypoints() index inserts the new data at the end.

Insert( (Trajectory)arg1, (int)index, (object)data, (ConfigurationSpecification)spec, (bool)overwrite) -> None :

void Insert(size_t index, const std::vector< dReal > & data, const ConfigurationSpecification & spec, bool bOverwrite = false )

Sets/inserts new waypoints in a configuration specification.

Parameters

index -

The index where to start modifying the trajectory.

data -

The data to insert, can represent multiple consecutive waypoints. data.size()/GetConfigurationSpecification().GetDOF() waypoints are added.

spec -

the specification in which the input data come in. Depending on what data is offered, some values of this trajectory’s specification might not be initialized.

bOverwrite -

If true, will overwrite the waypoints starting at index, and will insert new waypoints only if end of trajectory is reached; if the input spec does not overwrite all the data of the trjectory spec, then the original trajectory data will not be overwritten. If false, will insert the points before index: a 0 index inserts the new data in the beginning, a GetNumWaypoints() index inserts the new data at the end.

Read((Trajectory)arg1, (str)data, (object)robot) → bool :¶

bool Read(std::istream & I, RobotBaseConstPtr )

Remove((Trajectory)arg1, (int)startindex, (int)endindex) → None :¶

void Remove(size_t startindex, size_t endindex)

removes a number of waypoints starting at the specified index

Sample((Trajectory)arg1, (float)time) → object :¶

void Sample(std::vector< dReal > & data, dReal time)

samples a data point on the trajectory at a particular time

Parameters

data[out] -

the sampled point

time[in] -

the time to sample

Sample( (Trajectory)arg1, (float)time, (ConfigurationSpecification)spec) -> object :

void Sample(std::vector< dReal > & data, dReal time, const ConfigurationSpecification & spec)

samples a data point on the trajectory at a particular time and returns data for the group specified.

Parameters

data[out] -

the sampled point

time[in] -

the time to sample

spec[in] -

the specification format to return the data in The default implementation is slow, so interface developers should override it.

Write((Trajectory)arg1, (object)options) → object :¶

bool Write(std::ostream & O, int options)

deserialize((Trajectory)arg1, (str)data) → Trajectory :¶

InterfaceBasePtr deserialize(std::istream & I)

initialize the trajectory

serialize((Trajectory)arg1[, (object)options]) → object :¶

void serialize(std::ostream & O, int options = 0 )

output the trajectory in XML format

class openravepy.openravepy_int.TriMesh¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

__init__( (object)arg1, (object)vertices, (object)indices) -> None

indices¶

vertices¶

class openravepy.openravepy_int.UserData¶

Bases: Boost.Python.instance

Raises an exception This class cannot be instantiated from Python

Close((UserData)arg1) → None :¶

force releasing the user handle point.

close((UserData)arg1) → None :¶

deprecated

class openravepy.openravepy_int.Viewer¶

Bases: openravepy.openravepy_int.Interface

Raises an exception This class cannot be instantiated from Python

EnvironmentSync((Viewer)arg1) → None :¶

void EnvironmentSync()

forces synchronization with the environment, returns when the environment is fully synchronized.

Note that this method might not work if environment is locked in current thread

GetCameraImage((Viewer)arg1, (int)width, (int)height, (object)transform, (object)K) → object :¶

bool GetCameraImage(std::vector< uint8_t > & memory, int width, int height, const RaveTransform < float > & t, const SensorBase::CameraIntrinsics & intrinsics)

Renders a 24bit RGB image of dimensions width and height from the current scene.

Parameters

memory -

the memory where the image will be stored at, has to store 3*width*height

width -

width of the image, if 0 the width of the viewer is used

height -

height of the image, if 0 the width of the viewer is used

t -

the rotation and translation of the camera. Note that +z is treated as the camera direction axis! So all points in front of the camera have a positive dot product with its +z direction.

intrinsics -

the intrinsic parameters of the camera defining FOV, distortion, principal point, and focal length. The focal length is used to define the near plane for culling. The camera is meant to show the underlying OpenRAVE world as a robot would see it, so all graphs rendered with the plotX and drawX functions are hidden by default. Some viewers support the SetFiguresInCamera command to allow graphs to be also displayed.

GetCameraTransform((Viewer)arg1) → object :¶

RaveTransform < float > GetCameraTransform()

Return the current camera transform that the viewer is rendering the environment at.

GetName((Viewer)arg1) → str :¶

const std::string & GetName()

Move((Viewer)arg1, (int)arg2, (int)arg3) → None :¶

void Move(int x, int y)

RegisterCallback((Viewer)arg1, (object)arg2, (object)callback) → object :¶

UserDataPtr RegisterItemSelectionCallback(const ItemSelectionCallbackFn & fncallback)

registers a function with the viewer that gets called everytime mouse button is clicked

Return

a handle to the callback. If this handle is deleted, the callback will be unregistered.

RegisterItemSelectionCallback((Viewer)arg1, (object)callback) → object :¶

UserDataPtr RegisterItemSelectionCallback(const ItemSelectionCallbackFn & fncallback)

registers a function with the viewer that gets called everytime mouse button is clicked

Return

a handle to the callback. If this handle is deleted, the callback will be unregistered.

SetBkgndColor((Viewer)arg1, (object)arg2) → None :¶

void SetBkgndColor(const RaveVector< float > & color)

SetCamera((Viewer)arg1, (object)transform) → None :¶

void SetCamera(const RaveTransform < float > & trans, float focalDistance = 0 )

Set the camera transformation.

Parameters

trans -

new camera transformation in the world coordinate system

focalDistance -

The new focal distance of the camera (higher values is higher zoom). If 0, then the previous focal distance is preserved.

SetCamera( (Viewer)arg1, (object)transform, (float)focalDistance) -> None :

void SetCamera(const RaveTransform < float > & trans, float focalDistance = 0 )

Set the camera transformation.

Parameters

trans -

new camera transformation in the world coordinate system

focalDistance -

The new focal distance of the camera (higher values is higher zoom). If 0, then the previous focal distance is preserved.

SetName((Viewer)arg1, (str)arg2) → None :¶

void SetName(const std::string & name)

SetSize((Viewer)arg1, (int)arg2, (int)arg3) → None :¶

void SetSize(int w, int h)

SetTitle((Viewer)arg1, (str)arg2) → None :¶

void SetName(const std::string & name)

main((Viewer)arg1, (bool)show[, (int)sig_thread_id]) → int :¶

int main(bool bShow = true )

goes into the main loop

Parameters

bShow -

if true will show the window

quitmainloop((Viewer)arg1) → None :¶

void quitmainloop()

destroys the main loop

class openravepy.openravepy_int.VoidHandle¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

Close((VoidHandle)arg1) → None¶

close((VoidHandle)arg1) → None :¶

deprecated

class openravepy.openravepy_int.VoidPointer¶

Bases: Boost.Python.instance

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

__init__( (object)arg1) -> None

class openravepy.openravepy_int.XMLReadable¶

Bases: Boost.Python.instance

__init__( (object)arg1, (object)readableraw) -> None

GetXMLId((XMLReadable)arg1) → str¶

Serialize((XMLReadable)arg1[, (int)options]) → object¶

openravepy.openravepy_int.axisAngleFromQuat((object)quat) → object :¶

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

Converts a quaternion into the axis-angle representation.

Parameters

quat -

quaternion, (s,vx,vy,vz)

openravepy.openravepy_int.axisAngleFromRotationMatrix((object)rotation) → object :¶

RaveVector < T > axisAngleFromMatrix(const RaveTransformMatrix < T > & rotation)

Converts the rotation of a matrix into axis-angle representation.

Parameters

rotation -

3x3 rotation matrix

openravepy.openravepy_int.invertPoses((object)poses) → object :¶

Inverts a Nx7 array of poses where first 4 columns are the quaternion and last 3 are the translation components.

Parameters:	poses – nx7 array

openravepy.openravepy_int.matrixFromAxisAngle((object)axisangle) → object :¶

RaveTransformMatrix < T > matrixFromAxisAngle(const RaveVector < T > & axisangle)

Converts an axis-angle rotation to a 3x3 matrix.

Parameters

axis -

unit axis * rotation angle (radians), 3 values

matrixFromAxisAngle( (object)axis, (float)angle) -> object

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

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

Parameters:	pose – 7 values

openravepy.openravepy_int.matrixFromPoses((object)poses) → object :¶

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

Parameters:	poses – nx7 array

openravepy.openravepy_int.matrixFromQuat((object)quat) → object :¶

Converts a quaternion to a 4x4 affine matrix.

Parameters:	quat – 4 values

openravepy.openravepy_int.matrixSerialization((object)transform) → str :¶

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

Parameters:	transform – 3x4 or 4x4 array

openravepy.openravepy_int.normalizeAxisRotation((object)axis, (object)quat) → object :¶

std::pair< T, RaveVector < T > > normalizeAxisRotation(const RaveVector < T > & axis, const RaveVector < T > & quat)

Find the rotation theta around axis such that rot(axis,theta) * q is closest to the identity rotation.

Parameters

axis -

axis to minimize rotation about

quat -

input

Return

The angle that minimizes the rotation along with the normalized rotation rot(axis,theta)*q

openravepy.openravepy_int.openravepyCompilerVersion() → str :¶

Returns the compiler version that openravepy_int was compiled with

class openravepy.openravepy_int.options¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

returnTransformQuaternion = False¶

class openravepy.openravepy_int.planningutils¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

class ActiveDOFTrajectoryRetimer¶

Bases: Boost.Python.instance

__init__( (object)robot, (Robot)hastimestamps, (str)plannername, (str)plannerparameters) -> None

PlanPath((ActiveDOFTrajectoryRetimer)arg1, (Trajectory)traj[, (bool)hastimestamps[, (bool)releasegil]]) → PlannerStatus¶

class planningutils.ActiveDOFTrajectorySmoother¶

Bases: Boost.Python.instance

__init__( (object)arg1, (Robot)robot, (str)plannername, (str)plannerparameters) -> None

PlanPath((ActiveDOFTrajectorySmoother)arg1, (Trajectory)traj[, (bool)releasegil]) → PlannerStatus¶

class planningutils.AffineTrajectoryRetimer¶

Bases: Boost.Python.instance

__init__( (object)arg1, (str)plannername, (str)plannerparameters) -> None

PlanPath((AffineTrajectoryRetimer)arg1, (Trajectory)traj, (object)maxvelocities, (object)maxaccelerations[, (bool)hastimestamps[, (bool)releasegil]]) → PlannerStatus¶

planningutils.ComputeTrajectoryDerivatives((Trajectory)trajectory, (int)maxderiv) → None :¶

OPENRAVE_API void ComputeTrajectoryDerivatives(TrajectoryBasePtr traj, int maxderiv)

computes the trajectory derivatives and modifies the trajetory configuration to store them.

Parameters

traj -

the re-timed trajectory

maxderiv -

the maximum derivative to assure. If 1, will assure velocities, if 2 will assure accelerations, etc. If necessary will change the configuration specification of the trajectory. If more derivatives are requested than the trajectory supports, will ignore them. For example, acceleration of a linear trajectory.

planningutils.ConvertTrajectorySpecification((Trajectory)trajectory, (ConfigurationSpecification)spec) → None :¶

OPENRAVE_API void ConvertTrajectorySpecification(TrajectoryBasePtr traj, const ConfigurationSpecification & spec)

convert the trajectory and all its points to a new specification

class planningutils.DHParameter¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

__init__( (object)arg1) -> None

__init__( (object)arg1, (object)joint, (int)parentindex, (object)transform, (float)d, (float)a, (float)theta, (float)alpha) -> None

a¶

alpha¶

d¶

joint¶

parentindex¶

theta¶

transform¶

planningutils.GetDHParameters((KinBody)body) → list :¶

OPENRAVE_API void GetDHParameters(std::vector< DHParameter > & vparameters, KinBodyConstPtr pbody)

returns the Denavit-Hartenberg parameters of the kinematics structure of the body.

Parameters

vparameters -

One set of parameters are returned for each joint. Parameters

tstart -

the initial transform in the body coordinate system to the first joint If the robot has joints that cannot be represented by DH, will throw an exception. Passive joints are ignored. Joints are ordered by hierarchy dependency. By convention N joints give N-1 DH parameters, but GetDHParameters returns N parameters. The reason is because the first parameter is used to define the coordinate system of the first axis relative to the robot origin.

Note

The coordinate systems computed from the DH parameters do not match the OpenRAVE link coordinate systems.

See

DHParameter.

planningutils.InsertWaypointWithSmoothing((int)index, (object)dofvalues, (object)dofvelocities, (Trajectory)trajectory[, (float)maxvelmult[, (float)maxaccelmult[, (str)plannername]]]) → None :¶

OPENRAVE_API void InsertWaypointWithSmoothing(int index, const std::vector< dReal > & dofvalues, const std::vector< dReal > & dofvelocities, TrajectoryBasePtr traj, dReal fmaxvelmult = 1 , dReal fmaxaccelmult = 1 , const std::string & plannername = “” )

insert a waypoint in a timed trajectory and smooth so that the trajectory always goes through the waypoint at the specified velocity.

Parameters

index -

The index where to insert the new waypoint. A negative value starts from the end.

dofvalues -

the configuration to insert into the trajectcory (active dof values of the robot)

dofvelocities -

the velocities that the inserted point should start with

traj -

the trajectory that initially contains the input points, it is modified to contain the new re-timed data.

plannername -

the name of the planner to use to smooth. If empty, will use the default trajectory smoother. The PlannerParameters is automatically determined from the trajectory’s configuration space

planningutils.JitterTransform((KinBody)body, (float)jitter[, (int)maxiterations]) → bool¶

class planningutils.ManipulatorIKGoalSampler¶

Bases: Boost.Python.instance

__init__( (object)arg1, (object)manip, (object)parameterizations [, (int)nummaxsamples [, (int)nummaxtries [, (float)jitter [, (bool)searchfreeparameters]]]]) -> None

Sample((ManipulatorIKGoalSampler)arg1[, (bool)ikreturn[, (bool)releasegil]]) → object¶

SampleAll((ManipulatorIKGoalSampler)arg1[, (int)maxsamples[, (int)maxchecksamples[, (bool)releasegil]]]) → object¶

planningutils.MergeTrajectories((object)trajectories) → object :¶

OPENRAVE_API TrajectoryBasePtr MergeTrajectories(const std::list< TrajectoryBaseConstPtr > & listtrajectories)

merges the contents of multiple trajectories into one so that everything can be played simultaneously.

Exceptions

openrave_exception -

throws an exception if the trajectory data is incompatible and cannot be merged. Each trajectory needs to have a ‘deltatime’ group for timestamps. The trajectories cannot share common configuration data because only one trajectories’s data can be set at a time.

planningutils.RetimeActiveDOFTrajectory((Trajectory)trajectory, (Robot)robot[, (bool)hastimestamps[, (float)maxvelmult[, (float)maxaccelmult[, (str)plannername[, (str)plannerparameters]]]]]) → PlannerStatus :¶

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

Retime the trajectory points by extracting and using the currently set active dofs of the robot.

Parameters

traj -

the trajectory that initially contains the input points, it is modified to contain the new re-timed data.

robot -

use the robot’s active dofs to initialize the trajectory space

plannername -

the name of the planner to use to retime. If empty, will use the default trajectory re-timer.

hastimestamps -

if true, use the already initialized timestamps of the trajectory

plannerparameters -

XML string to be appended to PlannerBase::PlannerParameters::_sExtraParameters passed in to the planner. Collision is not checked. Every waypoint in the trajectory is guaranteed to be hit. The velocities for the current trajectory are overwritten. The returned trajectory will contain data only for the currenstly set active dofs of the robot.

planningutils.RetimeAffineTrajectory((Trajectory)trajectory, (object)maxvelocities, (object)maxaccelerations[, (bool)hastimestamps[, (str)plannername[, (str)plannerparameters]]]) → PlannerStatus :¶

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

Retime the trajectory points consisting of affine transformation values while avoiding collisions.

Parameters

traj -

the trajectory that initially contains the input points, it is modified to contain the new re-timed data.

maxvelocities -

the max velocities of each dof

maxaccelerations -

the max acceleration of each dof

plannername -

the name of the planner to use to retime. If empty, will use the default trajectory re-timer.

hastimestamps -

if true, use the already initialized timestamps of the trajectory

plannerparameters -

XML string to be appended to PlannerBase::PlannerParameters::_sExtraParameters passed in to the planner. Collision is not checked. Every waypoint in the trajectory is guaranteed to be hit. The velocities for the current trajectory are overwritten.

planningutils.RetimeTrajectory((Trajectory)trajectory[, (bool)hastimestamps[, (float)maxvelmult[, (float)maxaccelmult[, (str)plannername[, (str)plannerparameters]]]]]) → PlannerStatus :¶

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

Retime the trajectory points using all the positional data from the trajectory.

Parameters

traj -

the trajectory that initially contains the input points, it is modified to contain the new re-timed data.

plannername -

the name of the planner to use to retime. If empty, will use the default trajectory re-timer.

hastimestamps -

if true, use the already initialized timestamps of the trajectory

plannerparameters -

XML string to be appended to PlannerBase::PlannerParameters::_sExtraParameters passed in to the planner. Collision is not checked. Every waypoint in the trajectory is guaranteed to be hit. The velocities for the current trajectory are overwritten. The returned trajectory will contain data only for the currenstly set active dofs of the robot.

planningutils.ReverseTrajectory((Trajectory)trajectory) → object :¶

OPENRAVE_API TrajectoryBasePtr ReverseTrajectory(TrajectoryBaseConstPtr traj)

returns a new trajectory with the order of the waypoints and times reversed.

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

planningutils.SmoothActiveDOFTrajectory((Trajectory)trajectory, (Robot)robot[, (float)maxvelmult[, (float)maxaccelmult[, (str)plannername[, (str)plannerparameters]]]]) → PlannerStatus :¶

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

Smooth the trajectory points to avoiding collisions by extracting and using the currently set active dofs of the robot.

Parameters

traj -

the trajectory that initially contains the input points, it is modified to contain the new re-timed data.

robot -

use the robot’s active dofs to initialize the trajectory space

plannername -

the name of the planner to use to smooth. If empty, will use the default trajectory re-timer.

hastimestamps -

if true, use the already initialized timestamps of the trajectory

plannerparameters -

XML string to be appended to PlannerBase::PlannerParameters::_sExtraParameters passed in to the planner. Only initial and goal configurations are preserved. The velocities for the current trajectory are overwritten. The returned trajectory will contain data only for the currenstly set active dofs of the robot.

planningutils.SmoothAffineTrajectory((Trajectory)trajectory, (object)maxvelocities, (object)maxaccelerations[, (str)plannername[, (str)plannerparameters]]) → PlannerStatus :¶

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

Smooth the trajectory points consisting of affine transformation values while avoiding collisions.

Parameters

traj -

the trajectory that initially contains the input points, it is modified to contain the new re-timed data.

maxvelocities -

the max velocities of each dof

maxaccelerations -

the max acceleration of each dof

plannername -

the name of the planner to use to smooth. If empty, will use the default trajectory re-timer.

hastimestamps -

if true, use the already initialized timestamps of the trajectory

plannerparameters -

XML string to be appended to PlannerBase::PlannerParameters::_sExtraParameters passed in to the planner. Only initial and goal configurations are preserved.

planningutils.SmoothTrajectory((Trajectory)trajectory[, (float)maxvelmult[, (float)maxaccelmult[, (str)plannername[, (str)plannerparameters]]]]) → PlannerStatus :¶

OPENRAVE_API void SmoothTrajectory(TrajectoryBasePtr traj, dReal fmaxvelmult = 1 , dReal fmaxaccelmult = 1 , const std::string & plannername = “” , const std::string & plannerparameters = “” )

Smooth the trajectory points to avoiding collisions by extracting and using the positional data from the trajectory.

Parameters

traj -

the trajectory that initially contains the input points, it is modified to contain the new re-timed data.

plannername -

the name of the planner to use to smooth. If empty, will use the default trajectory re-timer.

hastimestamps -

if true, use the already initialized timestamps of the trajectory

plannerparameters -

XML string to be appended to PlannerBase::PlannerParameters::_sExtraParameters passed in to the planner. Only initial and goal configurations are preserved. The velocities for the current trajectory are overwritten. The returned trajectory will contain data only for the currenstly set active dofs of the robot.

planningutils.VerifyTrajectory((object)parameters, (Trajectory)trajectory, (float)samplingstep) → None :¶

void VerifyTrajectory(TrajectoryBaseConstPtr trajectory, dReal samplingstep)

openravepy.openravepy_int.poseFromMatrices((object)transforms) → object :¶

Converts an array/list of 4x4 matrices to a Nx7 array where each row is quaternion+translation representation.

Parameters:	transforms – list of 3x4 or 4x4 affine matrices

openravepy.openravepy_int.poseFromMatrix((object)transform) → object :¶

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

Parameters:	transform – 3x4 or 4x4 affine matrix

openravepy.openravepy_int.poseMult((object)pose1, (object)pose2) → object :¶

multiplies two poses.

Parameters:	pose1 – 7 values pose2 – 7 values

openravepy.openravepy_int.poseSerialization((object)pose) → str :¶

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

Parameters:	pose – 7 values

openravepy.openravepy_int.poseTransformPoints((object)pose, (object)points) → object :¶

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

Parameters:	pose – 7 values points – Nx3 values

openravepy.openravepy_int.quatFromAxisAngle((object)axisangle) → object :¶

RaveVector < T > quatFromAxisAngle(const RaveVector < T > & axisangle)

Converts an axis-angle rotation into a quaternion.

Parameters

axisangle -

unit axis * rotation angle (radians), 3 values

quatFromAxisAngle( (object)axis, (float)angle) -> object :

RaveVector < T > quatFromAxisAngle(const RaveVector < T > & axis, T angle)

Converts an axis-angle rotation into a quaternion.

Parameters

axis -

unit axis, 3 values

angle -

rotation angle (radians)

openravepy.openravepy_int.quatFromRotationMatrix((object)rotation) → object :¶

RaveVector < T > quatFromMatrix(const RaveTransformMatrix < T > & rotation)

Converts the rotation of a matrix into a quaternion.

Parameters

t -

transform for extracting the 3x3 rotation.

openravepy.openravepy_int.quatInverse((object)quat) → object :¶

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

Inverted a quaternion rotation.

Parameters

quat -

quaternion, (s,vx,vy,vz)

openravepy.openravepy_int.quatMult((object)quat0, (object)quat1) → object :¶

RaveVector < T > quatMultiply(const RaveVector < T > & quat0, const RaveVector < T > & quat1)

Multiply two quaternions.

Parameters

quat0 -

quaternion, (s,vx,vy,vz)

quat1 -

quaternion, (s,vx,vy,vz)

openravepy.openravepy_int.quatMultiply((object)quat0, (object)quat1) → object :¶

RaveVector < T > quatMultiply(const RaveVector < T > & quat0, const RaveVector < T > & quat1)

Multiply two quaternions.

Parameters

quat0 -

quaternion, (s,vx,vy,vz)

quat1 -

quaternion, (s,vx,vy,vz)

openravepy.openravepy_int.quatRotateDirection((object)arg1, (object)sourcedir, targetdir) → object :¶

RaveVector < T > quatRotateDirection(const RaveVector < T > & sourcedir, const RaveVector < T > & targetdir)

Return the minimal quaternion that orients sourcedir to targetdir.

Parameters

sourcedir -

direction of the original vector, 3 values

targetdir -

new direction, 3 values

openravepy.openravepy_int.quatSlerp((object)quat0, (object)quat1, (float)t) → object :¶

RaveVector < T > quatSlerp(const RaveVector < T > & quat0, const RaveVector < T > & quat1, T t)

Sphereical linear interpolation between two quaternions.

Parameters

quat0 -

quaternion, (s,vx,vy,vz)

quat1 -

quaternion, (s,vx,vy,vz)

t -

real value in [0,1]. 0 returns quat1, 1 returns quat2

openravepy.openravepy_int.raveGetDebugLevel() → int :¶

OPENRAVE_API int RaveGetDebugLevel()

Returns the openrave debug level.

openravepy.openravepy_int.raveLog((str)log, (int)level) → None :¶

Send a log to the openrave system with excplicit level

openravepy.openravepy_int.raveLogDebug((str)log) → None :¶

Send a debug log to the openrave system

openravepy.openravepy_int.raveLogError((str)log) → None :¶

Send an error log to the openrave system

openravepy.openravepy_int.raveLogFatal((str)log) → None :¶

Send a fatal log to the openrave system

openravepy.openravepy_int.raveLogInfo((str)log) → None :¶

Send an info log to the openrave system

openravepy.openravepy_int.raveLogVerbose((str)log) → None :¶

Send a verbose log to the openrave system

openravepy.openravepy_int.raveLogWarn((str)log) → None :¶

Send a warn log to the openrave system

openravepy.openravepy_int.raveSetDebugLevel((object)level) → None :¶

OPENRAVE_API void RaveSetDebugLevel(int level)

Sets the global openrave debug level. A combination of DebugLevel.

openravepy.openravepy_int.rotationMatrixFromAxisAngle((object)axisangle) → object :¶

RaveTransformMatrix < T > matrixFromAxisAngle(const RaveVector < T > & axisangle)

Converts an axis-angle rotation to a 3x3 matrix.

Parameters

axis -

unit axis * rotation angle (radians), 3 values

rotationMatrixFromAxisAngle( (object)axis, (float)angle) -> object

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

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

Parameters:	quatarray – nx4 array

openravepy.openravepy_int.rotationMatrixFromQuat((object)quat) → object :¶

RaveTransformMatrix < T > matrixFromQuat(const RaveVector < T > & quat)

Converts a quaternion to a 3x3 matrix.

Parameters

quat -

quaternion, (s,vx,vy,vz)

openravepy.openravepy_int.transformLookat((object)lookat, (object)camerapos, (object)cameraup) → object :¶

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

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

class openravepy.openravepy_int.xmlreaders¶

Bases: Boost.Python.instance

__init__( (object)arg1) -> None

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