java.lang.Object
- org.robwork.sdurw_models.SE3DevicePtr

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

Constructor Summary

Constructors
Constructor	Description
`SE3DevicePtr()`	Default constructor yielding a NULL-pointer.
`SE3DevicePtr(long cPtr, boolean cMemoryOwn)`
`SE3DevicePtr(SE3Device 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
`SE3Device`	`__ref__()`	Dereferencing operator.
`JacobianCalculatorPtr`	`baseJCend(State state)`	DeviceJacobian for the end frame. By default this method forwards to baseDJframe().
`JacobianCalculatorPtr`	`baseJCframe(FrameCPtr frame, State state)`	DeviceJacobian for a particular frame. By default this method forwards to baseDJframes().
`JacobianCalculatorPtr`	`baseJCframes(FrameVector frames, State state)`
`Jacobian`	`baseJend(State state)`
`Jacobian`	`baseJframe(FrameCPtr frame, State state)`	Calculates the jacobian matrix of a frame f described in the robot base frame ^{base}_{frame}\mathbf{J}_{\mathbf{q}}(\mathbf{q})
`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.
`Transform3D`	`baseTend(State state)`	Calculates the homogeneous transform from base to the end frame \robabx{base}{end}{\mathbf{T}}
`Transform3D`	`baseTframe(FrameCPtr f, State state)`	Calculates the homogeneous transform from base to a frame f \robabx{b}{f}{\mathbf{T}}
`SE3DeviceCPtr`	`cptr()`
`void`	`delete()`
`SE3Device`	`deref()`	The pointer stored in the object.
`boolean`	`equals(SE3Device p)`
`Q`	`getAccelerationLimits()`	get the Joint Acceleration limit
`Frame`	`getBase()`	get base of the device
`PairQ`	`getBounds()`	Since the SE3Device robot is unconstrained and can move anywhere whithin the taskspace each of the 6 input's are unbounded ( [-\inf, \inf] ) in practice the inputs are limited to the numerical limits of the real datatype, thus this method returns the range ([DBL_MIN, DBL_MAX]) for each of the 6 inputs
`static long`	`getCPtr(SE3DevicePtr obj)`
`SE3Device`	`getDeref()`	Member access operator.
`long`	`getDOF()`	This method always returns the value 6
`Frame`	`getEnd()`	get end of the device
`java.lang.String`	`getName()`	Returns the name of the device
`PropertyMap`	`getPropertyMap()`
`Q`	`getQ(State state)`
`StateStructurePtr`	`getStateStructure()`	Get the state structure.
`Q`	`getVelocityLimits()`	get the Joint velocity limit
`boolean`	`isNull()`	checks if the pointer is null
`boolean`	`isRegistered()`	Check if object has registered its state.
`boolean`	`isShared()`	check if this Ptr has shared ownership or none ownership
`void`	`registerIn(State state)`	initialize this stateless data to a specific state
`void`	`registerIn(StateStructurePtr state)`	register this stateless object in a statestructure.
`void`	`setAccelerationLimits(Q acclimits)`	set the Joint Acceleration limit
`void`	`setBounds(PairQ bounds)`	set outer bound of the device
`void`	`setName(java.lang.String name)`	Sets the name of the Device
`void`	`setQ(Q q, State state)`
`void`	`setVelocityLimits(Q vellimits)`	set the Joint velocity limit
`java.lang.String`	`toString()`
`void`	`unregister()`	unregisters all state data of this stateless object
`Transform3D`	`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, wait, wait, wait

- Constructor Detail
  - SE3DevicePtr
```
public SE3DevicePtr(long cPtr,
                    boolean cMemoryOwn)
```
  - SE3DevicePtr
```
public SE3DevicePtr()
```
    Default constructor yielding a NULL-pointer.
  - SE3DevicePtr
```
public SE3DevicePtr(SE3Device ptr)
```
    Do not take ownership of ptr.
    
    ptr can be null.
    
    The constructor is implicit on purpose.
- Method Detail
  - getCPtr
```
public static long getCPtr(SE3DevicePtr obj)
```
  - delete
```
public void delete()
```
  - deref
```
public SE3Device deref()
```
    The pointer stored in the object.
  - __ref__
```
public SE3Device __ref__()
```
    Dereferencing operator.
  - getDeref
```
public SE3Device getDeref()
```
    Member access operator.
  - equals
```
public boolean equals(SE3Device 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
  - cptr
```
public SE3DeviceCPtr cptr()
```
  - setQ
```
public void setQ(Q q,
                 State state)
```
  - getQ
```
public Q getQ(State state)
```
  - getBounds
```
public PairQ getBounds()
```
    Since the SE3Device robot is unconstrained and can move anywhere
    whithin the taskspace each of the 6 input's are unbounded ( [-\inf, \inf] ) in practice the inputs are limited to the
    numerical limits of the real datatype, thus this method returns the
    range ([DBL_MIN, DBL_MAX]) for each of the 6 inputs
  - getBase
```
public Frame getBase()
```
    get base of the device
    
    Returns:
    
    base Frame
  - getEnd
```
public Frame getEnd()
```
    get end of the device
    
    Returns:
    
    end Frame
  - baseJend
```
public Jacobian baseJend(State state)
```
  - baseJCframes
```
public JacobianCalculatorPtr baseJCframes(FrameVector frames,
                                          State state)
```
  - getDOF
```
public long getDOF()
```
    This method always returns the value 6
  - setBounds
```
public void setBounds(PairQ bounds)
```
    set outer bound of the device
    
    Parameters:
    
    bounds - [in] the minimum Q and the maximum Q
  - getVelocityLimits
```
public Q getVelocityLimits()
```
    get the Joint velocity limit
    
    Returns:
    
    the velocity limit as Q
  - setVelocityLimits
```
public void setVelocityLimits(Q vellimits)
```
    set the Joint velocity limit
    
    Parameters:
    
    vellimits - [in] the velocity limit as Q
  - getAccelerationLimits
```
public Q getAccelerationLimits()
```
    get the Joint Acceleration limit
    
    Returns:
    
    the Acceleration limit as Q
  - setAccelerationLimits
```
public void setAccelerationLimits(Q acclimits)
```
    set the Joint Acceleration limit
    
    Parameters:
    
    acclimits - [in] the acceleration limit as Q
  - 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 Transform3D baseTframe(FrameCPtr 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 Transform3D 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 Transform3D 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}}
  - baseJframe
```
public Jacobian baseJframe(FrameCPtr frame,
                           State state)
```
    Calculates the jacobian matrix of a frame f described in the
    robot base frame ^{base}_{frame}\mathbf{J}_{\mathbf{q}}(\mathbf{q})
    
    Parameters:
    
    frame - [in] Frame for which to calculate the Jacobian
    
    state - [in] State for which to calculate the Jacobian
    
    Returns:
    
    the 6*ndof jacobian matrix: {^{base}_{frame}}\mathbf{J}_{\mathbf{q}}(\mathbf{q})
    
    This method calculates the jacobian relating joint velocities ( \mathbf{\dot{q}} ) to the frame f velocity seen from base-frame
    ( \nu^{base}_{frame} )
    
    \nu^{base}_{frame} = {^{base}_{frame}}\mathbf{J}_\mathbf{q}(\mathbf{q})\mathbf{\dot{q}}
    
    The jacobian matrix {^{base}_n}\mathbf{J}_{\mathbf{q}}(\mathbf{q})
    is defined as:
    
    {^{base}_n}\mathbf{J}_{\mathbf{q}}(\mathbf{q}) = \frac{\partial ^{base}\mathbf{x}_n}{\partial \mathbf{q}}
    
    By default the method forwards to baseJframes().
  - 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
  - baseJCend
```
public JacobianCalculatorPtr baseJCend(State state)
```
    DeviceJacobian for the end frame.
    
    By default this method forwards to baseDJframe().
  - baseJCframe
```
public JacobianCalculatorPtr baseJCframe(FrameCPtr frame,
                                         State state)
```
    DeviceJacobian for a particular frame.
    
    By default this method forwards to baseDJframes().
  - getPropertyMap
```
public PropertyMap getPropertyMap()
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - registerIn
```
public void registerIn(State state)
```
    initialize this stateless data to a specific state
    
    Parameters:
    
    state - [in] the state in which to register the data.
    
    Note: the data will be registered in the state structure of the state
    and any copies or other instances of the state will therefore also
    contain the added states.
  - registerIn
```
public void registerIn(StateStructurePtr state)
```
    register this stateless object in a statestructure.
  - unregister
```
public void unregister()
```
    unregisters all state data of this stateless object
  - getStateStructure
```
public StateStructurePtr getStateStructure()
```
    Get the state structure.
    
    Returns:
    
    the state structure.
  - isRegistered
```
public boolean isRegistered()
```
    Check if object has registered its state.
    
    Returns:
    
    true if registered, false otherwise.

Class SE3DevicePtr

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

SE3DevicePtr

SE3DevicePtr

SE3DevicePtr

Method Detail

getCPtr

delete

deref

__ref__

getDeref

equals

isShared

isNull

cptr

setQ

getQ

getBounds

getBase

getEnd

baseJend

baseJCframes

getDOF

setBounds

getVelocityLimits

setVelocityLimits

getAccelerationLimits

setAccelerationLimits

getName

setName

baseTframe

baseTend

worldTbase

baseJframe

baseJframes

baseJCend

baseJCframe

getPropertyMap

toString

registerIn

registerIn

unregister

getStateStructure

isRegistered

ref