java.lang.Object
- org.robwork.sdurw.ParallelDevicePtr

```
public class ParallelDevicePtr
extends java.lang.Object
```
Ptr stores a pointer and optionally takes ownership of the value.

Constructor Summary

Constructors
Constructor	Description
`ParallelDevicePtr()`	Default constructor yielding a NULL-pointer.
`ParallelDevicePtr(long cPtr, boolean cMemoryOwn)`
`ParallelDevicePtr(ParallelDevice ptr)`	Do not take ownership of ptr. ptr can be null. The constructor is implicit on purpose.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`ParallelDevice`	`__ref__()`	Dereferencing operator.
`JacobianCalculatorPtr`	`baseJCframes(FrameVector frames, State state)`
`Jacobian`	`baseJend(State state)`
`Jacobian`	`baseJframe(Frame frame, State state)`
`Jacobian`	`baseJframes(FrameVector frames, State state)`	The Jacobian for a sequence of frames. A Jacobian is computed for each of the frames and the Jacobians are stacked on top of eachother.
`Transform3Dd`	`baseTend(State state)`	Calculates the homogeneous transform from base to the end frame \robabx{base}{end}{\mathbf{T}}
`Transform3Dd`	`baseTframe(Frame f, State state)`	Calculates the homogeneous transform from base to a frame f \robabx{b}{f}{\mathbf{T}}
`void`	`delete()`
`ParallelDevice`	`deref()`	The pointer stored in the object.
`boolean`	`equals(ParallelDevice p)`
`Q`	`getAccelerationLimits()`
`JointPointerVector`	`getActiveJoints()`	The active joints of the parallel device.
`PairQ`	`getAllBounds()`	Get bounds for all joints (includes both active and passive joints).
`JointPointerVector`	`getAllJoints()`	Get all joints (both active and passive).
`Frame`	`getBase()`
`PairQ`	`getBounds()`
`static long`	`getCPtr(ParallelDevicePtr obj)`
`ParallelDevice`	`getDeref()`	Member access operator.
`long`	`getDOF()`
`Frame`	`getEnd()`
`long`	`getFullDOF()`	Get the total degrees of freedom for all (active and passive) joints in the device.
`Q`	`getFullQ(State state)`	Get the full configuration vector of the device.
`JointPointerVector`	`getJoints()`	Get all joints of this device
`ParallelLegPointerVectorVector`	`getJunctions()`	Get the junctions of the device.
`ParallelLegPointerVector`	`getLegs()`	The legs of the parallel device.
`java.lang.String`	`getName()`	Returns the name of the device
`PropertyMap`	`getPropertyMap()`	Miscellaneous properties of the device. The property map of the device is provided to let the user store various settings for the device.
`Q`	`getQ(State state)`
`Q`	`getVelocityLimits()`
`boolean`	`isNull()`	checks if the pointer is null
`boolean`	`isShared()`	check if this Ptr has shared ownership or none ownership
`void`	`setAccelerationLimits(Q acclimits)`
`void`	`setBounds(PairQ bounds)`
`void`	`setFullQ(Q q, State state)`	Set the full configuration of the device. This sets the joint values directly, and there is no checks or guarantees that the device will be in a valid connected configuration afterwards.
`void`	`setName(java.lang.String name)`	Sets the name of the Device
`void`	`setQ(Q q, Vectorbool enabled, State state)`	Set only some of the actuated joints. This version of setQ will only set a subset of the actuated joints. Based on the value of q, the function will compute the values for the unactuated (passive) joints, and the remaining actuated joints. This is mainly useful for parallel devices that have more controlled joints than strictly required to make the kinematics determined.
`void`	`setQ(Q q, State state)`	The configuration q is the configuration for the actuated joints of the parallel device.
`void`	`setVelocityLimits(Q vellimits)`
`Transform3Dd`	`worldTbase(State state)`	Calculates the homogeneous transform from world to base \robabx{w}{b}{\mathbf{T}}

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ParallelDevicePtr
```
public ParallelDevicePtr(long cPtr,
                         boolean cMemoryOwn)
```
  - ParallelDevicePtr
```
public ParallelDevicePtr()
```
    Default constructor yielding a NULL-pointer.
  - ParallelDevicePtr
```
public ParallelDevicePtr(ParallelDevice ptr)
```
    Do not take ownership of ptr.
    
    ptr can be null.
    
    The constructor is implicit on purpose.
- Method Detail
  - getCPtr
```
public static long getCPtr(ParallelDevicePtr obj)
```
  - delete
```
public void delete()
```
  - deref
```
public ParallelDevice deref()
```
    The pointer stored in the object.
  - __ref__
```
public ParallelDevice __ref__()
```
    Dereferencing operator.
  - getDeref
```
public ParallelDevice getDeref()
```
    Member access operator.
  - equals
```
public boolean equals(ParallelDevice p)
```
  - isShared
```
public boolean isShared()
```
    check if this Ptr has shared ownership or none
    ownership
    
    Returns:
    
    true if Ptr has shared ownership, false if it has no ownership.
  - isNull
```
public boolean isNull()
```
    checks if the pointer is null
    
    Returns:
    
    Returns true if the pointer is null
  - setQ
```
public void setQ(Q q,
                 State state)
```
    The configuration q is the configuration for the actuated joints
    of the parallel device. Based on the value of q the setQ() method
    automatically computes the values for the unactuated (passive)
    joints.
  - setQ
```
public void setQ(Q q,
                 Vectorbool enabled,
                 State state)
```
    Set only some of the actuated joints.
    
    This version of setQ will only set a subset of the actuated joints.
    Based on the value of
    q, the function will compute the values for the
    unactuated (passive) joints, and the remaining actuated joints.
    
    This is mainly useful for parallel devices that have more controlled joints
    than strictly required to make the kinematics determined.
    
    Parameters:
    
    q - [in] the configuration of the actuated joints
    (the only considered elements are the ones where the corresponding elements of enabled
    is true).
    
    enabled - [in] vector of same size as q, specifying which values to solve for.
    
    state - [in/out] the state with all active and passive joint values.
    The input state is expected to contain a valid and consistent configuration of the
    device.
  - baseJframe
```
public Jacobian baseJframe(Frame frame,
                           State state)
```
  - baseJend
```
public Jacobian baseJend(State state)
```
  - getLegs
```
public ParallelLegPointerVector getLegs()
```
    The legs of the parallel device.
  - getJunctions
```
public ParallelLegPointerVectorVector getJunctions()
```
    Get the junctions of the device.
    
    Returns:
    
    a vector of junctions. Each junction is given by a two or more legs.
  - getActiveJoints
```
public JointPointerVector getActiveJoints()
```
    The active joints of the parallel device.
  - getAllJoints
```
public JointPointerVector getAllJoints()
```
    Get all joints (both active and passive).
    
    Returns:
    
    a vector of all the joints.
  - getFullDOF
```
public long getFullDOF()
```
    Get the total degrees of freedom for all (active and passive) joints in the
    device.
    
    Returns:
    
    the total degrees of freedom.
  - getAllBounds
```
public PairQ getAllBounds()
```
    Get bounds for all joints (includes both active and passive joints).
    
    Returns:
    
    a pair with the lower and upper limits.
  - getFullQ
```
public Q getFullQ(State state)
```
    Get the full configuration vector of the device. This gives the complete state of
    the parallel device.
    
    Parameters:
    
    state - [in] the state that contains the full configuration.
    
    Returns:
    
    the configuration vector with the joint values for both active and passive
    joints.
  - setFullQ
```
public void setFullQ(Q q,
                     State state)
```
    Set the full configuration of the device.
    This sets the joint values directly, and there is no checks or guarantees that the device
    will be in a valid connected configuration afterwards.
    
    Parameters:
    
    q - [in] the configuration vector to set.
    
    state - [in/out] the state to update with a new configuration.
  - getJoints
```
public JointPointerVector getJoints()
```
    Get all joints of this device
    
    Returns:
    
    all joints
  - getQ
```
public Q getQ(State state)
```
  - getDOF
```
public long getDOF()
```
  - getBounds
```
public PairQ getBounds()
```
  - setBounds
```
public void setBounds(PairQ bounds)
```
  - getVelocityLimits
```
public Q getVelocityLimits()
```
  - setVelocityLimits
```
public void setVelocityLimits(Q vellimits)
```
  - getAccelerationLimits
```
public Q getAccelerationLimits()
```
  - setAccelerationLimits
```
public void setAccelerationLimits(Q acclimits)
```
  - baseJCframes
```
public JacobianCalculatorPtr baseJCframes(FrameVector frames,
                                          State state)
```
  - getBase
```
public Frame getBase()
```
  - getEnd
```
public Frame getEnd()
```
  - getName
```
public java.lang.String getName()
```
    Returns the name of the device
    
    Returns:
    
    name of the device
  - setName
```
public void setName(java.lang.String name)
```
    Sets the name of the Device
    
    Parameters:
    
    name - [in] the new name of the frame
  - baseTframe
```
public Transform3Dd baseTframe(Frame f,
                               State state)
```
    Calculates the homogeneous transform from base to a frame f
    \robabx{b}{f}{\mathbf{T}}
    
    Returns:
    
    the homogeneous transform \robabx{b}{f}{\mathbf{T}}
  - baseTend
```
public Transform3Dd baseTend(State state)
```
    Calculates the homogeneous transform from base to the end frame
    \robabx{base}{end}{\mathbf{T}}
    
    Returns:
    
    the homogeneous transform \robabx{base}{end}{\mathbf{T}}
  - worldTbase
```
public Transform3Dd worldTbase(State state)
```
    Calculates the homogeneous transform from world to base \robabx{w}{b}{\mathbf{T}}
    
    Returns:
    
    the homogeneous transform \robabx{w}{b}{\mathbf{T}}
  - baseJframes
```
public Jacobian baseJframes(FrameVector frames,
                            State state)
```
    The Jacobian for a sequence of frames.
    
    A Jacobian is computed for each of the frames and the Jacobians are
    stacked on top of eachother.
    
    Parameters:
    
    frames - [in] the frames to calculate the frames from
    
    state - [in] the state to calculate in
    
    Returns:
    
    the jacobian
  - getPropertyMap
```
public PropertyMap getPropertyMap()
```
    Miscellaneous properties of the device.
    
    The property map of the device is provided to let the user store
    various settings for the device. The settings are typically loaded
    from setup files.
    
    The low-level manipulations of the property map can be cumbersome. To
    ease these manipulations, the PropertyAccessor utility class has been
    provided. Instances of this class are provided for a number of common
    settings, however it is undecided if these properties are a public
    part of RobWork.
    
    Returns:
    
    The property map of the device.

Class ParallelDevicePtr

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ParallelDevicePtr

ParallelDevicePtr

ParallelDevicePtr

Method Detail

getCPtr

delete

deref

__ref__

getDeref

equals

isShared

isNull

setQ

setQ

baseJframe

baseJend

getLegs

getJunctions

getActiveJoints

getAllJoints

getFullDOF

getAllBounds

getFullQ

setFullQ

getJoints

getQ

getDOF

getBounds

setBounds

getVelocityLimits

setVelocityLimits

getAccelerationLimits

setAccelerationLimits

baseJCframes

getBase

getEnd

getName

setName

baseTframe

baseTend

worldTbase

baseJframes

getPropertyMap

ref