`pyhpp.pinocchio`

`ComputationFlag`

Inherits: int

`Device`

Robot with geometric and dynamic pinocchio.

The creation of the device is done by Device::create(const

std::string name). This function returns a shared pointer to the newly created object. Smart pointers documentation: http://www.boost.org/libs/smart_ptr/smart_ptr.htm

def	Description
`def init(self, arg2: str) -> object`
`def computeForwardKinematics(self, self_: int) -> None`	Compute forward kinematics computing everything.
`def computeFramesForwardKinematics(self) -> None`
`def configSize(self) -> int`
`def configSpace(self) -> LiegroupSpace`	Returns a LiegroupSpace representing the configuration space.
`@typing.overload def currentConfiguration(self) -> numpy.ndarray @typing.overload def currentConfiguration(self, arg2: numpy.ndarray) -> bool`	Get current configuration.
`def data(self) -> pinocchio.pinocchio_pywrap_default.Data`
`def geomData(self) -> pinocchio.pinocchio_pywrap_default.GeometryData`
`def geomModel(self) -> pinocchio.pinocchio_pywrap_default.GeometryModel`
`def getCenterOfMass(self) -> numpy.ndarray`
`def getJointPosition(self, arg2: str) -> list`
`def getJointsPosition(self, arg2: numpy.ndarray, arg3: list) -> list`
`def model(self) -> pinocchio.pinocchio_pywrap_default.Model`
`def name(self) -> str`	Get name of device.
`def numberDof(self) -> int`
`def removeJoints(self, arg2: pinocchio.pinocchio_pywrap_default.StdVec_StdString, arg3: numpy.ndarray) -> None`
`def setJointBounds(self, arg2: str, arg3: list) -> None`
`def updateGeometryPlacements(self) -> None`	Update the geometry placement to the currentConfiguration.
`def visualModel(self) -> pinocchio.pinocchio_pywrap_default.GeometryModel`
`@property def rankInConfiguration(self) -> dict`

`Gripper`

Definition of a robot gripper

This class represent a robot gripper as a frame attached to the joint of the robot that holds the gripper.

To graps a box-shaped object with small lengths along x and y, the gripper frame should coincide with the object frame.

def	Description
`def getParentJointId(self) -> int`	Get index of the joint the handle is attached to in pinocchio Model
`def name(self) -> str`
`@property def clearance(self) -> float @clearance.setter def clearance(self, arg2: float) -> None`
`@property def localPosition(self) -> pinocchio.pinocchio_pywrap_default.SE3`

`GripperMap`

def	Description
`def contains(self, arg2: object) -> bool`
`def delitem(self, key: str) -> None`
`def getitem(self, key: str) -> Gripper`
`def init(self) -> None`
`def iter(self) -> typing.Iterator[str]`
`def len(self) -> int`
`def setitem(self, key: str, value: Gripper) -> None`

`LiegroupElement`

hpp::pinocchio::LiegroupElement

def	Description
`def add(self, arg2: numpy.ndarray) -> object`
`@typing.overload def init(self, arg2: numpy.ndarray, arg3: LiegroupSpace) -> None @typing.overload def init(self, arg2: LiegroupSpace) -> None`
`def str(self) -> str`
`def sub(self, arg2: LiegroupElement) -> object`
`def space(self) -> LiegroupSpace`	list index out of range
`def vector(self) -> numpy.ndarray`	list index out of range
`@property def v(self) -> numpy.ndarray @v.setter def v(self, arg2: numpy.ndarray) -> None`

`LiegroupElementRef`

hpp::pinocchio::LiegroupElementRef

def	Description
`def add(self, arg2: numpy.ndarray) -> object`
`def init(self, arg2: numpy.ndarray, arg3: LiegroupSpace) -> None`
`def str(self) -> str`
`def sub(self, arg2: LiegroupElementRef) -> object`
`def space(self) -> LiegroupSpace`	list index out of range
`def vector(self) -> numpy.ndarray`	list index out of range
`@property def v(self) -> numpy.ndarray @v.setter def v(self, arg2: numpy.ndarray) -> None`

`LiegroupSpace`

Cartesian product of elementary Lie groups

Some values produced and manipulated by functions belong to Lie groups For instance rotations, rigid-body motions are element of Lie groups.

Elements of Lie groups are usually applied common operations, like

integrating a velocity from a given element during unit time,

computing the constant velocity that moves from one element to another one in unit time.

By analogy with vector spaces that are a particular type of Lie group, the above operations are implemented as operators + and - respectively acting on LiegroupElement instances.

This class represents a Lie group as the cartesian product of elementaty Lie groups. Those elementary Lie groups are gathered in a variant called LiegroupType.

Elements of a Lie group are represented by class LiegroupElement.

def	Description
`@staticmethod def R1(rotation: bool) -> LiegroupSpace`	rotation — whether values of this space represent angles or lengths.
`@staticmethod def R2() -> LiegroupSpace`	Return $R^{2}$ as a Lie group.
`@staticmethod def R2xSO2() -> LiegroupSpace`	Return $R^{2} \times SO (2)$ .
`@staticmethod def R3() -> LiegroupSpace`	Return $R^{3}$ as a Lie group.
`@staticmethod def R3xSO3() -> LiegroupSpace`	Return $R^{3} \times SO (3)$ .
`@staticmethod def Rn(n: int) -> LiegroupSpace`	n — dimension of vector space
`@staticmethod def SE2() -> LiegroupSpace`	Return $SE (2)$ .
`@staticmethod def SE3() -> LiegroupSpace`	Return $SE (3)$ .
`def eq(self, arg2: LiegroupSpace) -> object`
`def imul(self, arg2: LiegroupSpace) -> LiegroupSpace`
`def mul(self, arg2: LiegroupSpace) -> LiegroupSpace`
`def ne(self, arg2: LiegroupSpace) -> object`
`def str(self) -> str`
`def dDifference_dq0(self, arg2: object, arg3: numpy.ndarray, arg4: numpy.ndarray, arg5: numpy.ndarray) -> None`
`def dDifference_dq1(self, arg2: object, arg3: numpy.ndarray, arg4: numpy.ndarray, arg5: numpy.ndarray) -> None`
`@staticmethod def dIntegrate_dq(arg1: object, arg2: object, arg3: numpy.ndarray, arg4: numpy.ndarray) -> None`
`@staticmethod def dIntegrate_dv(arg1: object, arg2: object, arg3: numpy.ndarray, arg4: numpy.ndarray) -> None`
`@staticmethod def empty() -> LiegroupSpace`	Return empty Lie group.
`def mergeVectorSpaces(self) -> None`
`def name(self) -> str`	Return name of Lie group.

`map_indexing_suite_GripperMap_entry`

def	Description
`def init(self) -> None`
`def repr(self) -> object`
`def data(self) -> Gripper`
`def key(self) -> str`

Keyboard shortcuts

Humanoid Path Planner