Package org.robwork.sdurw_models

Class DependentJointPtr

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

    • Constructor Detail

      • DependentJointPtr

        public DependentJointPtr​(long cPtr,
                         boolean cMemoryOwn)

      • DependentJointPtr

        public DependentJointPtr()
        Default constructor yielding a NULL-pointer.

      • DependentJointPtr

        public DependentJointPtr​(DependentJoint ptr)
        Do not take ownership of ptr.

        ptr can be null.

        The constructor is implicit on purpose.

    • Method Detail

      • delete

        public void delete()

      • deref

        public DependentJoint deref()
        The pointer stored in the object.

      • 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

      • isControlledBy

        public boolean isControlledBy​(Joint joint)
        Returns true if the DependentJoint is controlled by joint.

        A DependentJoint may depend on more than one joints.

        Parameters:
        joint - [in] Joints to test with
        Returns:
        True if this is controlled by joint

      • setBounds

        public void setBounds​(PairConstQ bounds)
        Sets joint bounds
        Parameters:
        bounds - [in] the lower and upper bounds of this joint

      • setBounds

        public void setBounds​(Q lower,
                      Q upper)
        Sets joint bounds
        Parameters:
        lower - [in] the lower of this joint
        upper - [in] the upper of this joint

      • getBounds

        public PairQ getBounds()
        Gets joint bounds
        Returns:
        the lower and upper bound of this joint

      • setMaxVelocity

        public void setMaxVelocity​(Q maxVelocity)
        Sets max velocity of joint
        Parameters:
        maxVelocity - [in] the new maximum velocity of the joint

      • getMaxVelocity

        public Q getMaxVelocity()
        Gets max velocity of joint
        Returns:
        the maximum velocity of the joint

      • setMaxAcceleration

        public void setMaxAcceleration​(Q maxAcceleration)
        Sets max acceleration of joint
        Parameters:
        maxAcceleration - [in] the new maximum acceleration of the joint

      • getMaxAcceleration

        public Q getMaxAcceleration()
        Gets max acceleration of joint
        Returns:
        the maximum acceleration of the joint

      • getJacobian

        public void getJacobian​(long row,
                        long col,
                        Transform3D joint,
                        Transform3D tcp,
                        State state,
                        Jacobian jacobian)
        Finds the Jacobian of the joints and adds it in jacobian.

        Calculates the Jacobian contribution to the device Jacobian when controlling a frame
        tcp and given a current joint pose joint.

        The values are stored from row row to row+5 and column col to
        col+(joint.getDOF()-1).

        Parameters:
        row - [in] Row where values should be stored
        col - [in] Column where values should be stored
        joint - [in] Transform of the joint
        tcp - [in] Transformation of the point to control
        state -
        jacobian - [in] Jacobian to which to add the results.

      • getFixedTransform

        public Transform3D getFixedTransform()
        get the fixed transform from parent to this joint

        Notice that this does not include the actual rotation of the joint (its state)
        only its fixed transform.

        Returns:
        fixed part of transform from paretn to joint

      • setFixedTransform

        public void setFixedTransform​(Transform3D t3d)
        change the transform from parent to joint base.
        Parameters:
        t3d - [in] the new transform.

      • getJointTransform

        public Transform3D getJointTransform​(State state)
        get the isolated joint transformation which is purely dependent on
        q.
        Parameters:
        state - [in] the state from which to extract q
        Returns:
        the joint transformation

      • setActive

        public void setActive​(boolean isActive)
        set the active state of the joint
        Parameters:
        isActive - [in] true to enable control/motorization of joint, false otherwise

      • isActive

        public boolean isActive()
        a joint is active if its motorized/controlled in some
        fasion. passive or non-active joints are typically used in parrallel robots.
        Returns:

      • setJointMapping

        public void setJointMapping​(SWIGTYPE_p_rw__math__Function1DiffT_double_double_double_t__Ptr function)
        set the function to be used in transforming from the state q to the actual q
        needed.

        This function can be used e.g. by a calibration.
        Parameters:
        function - [in] function with first order derivative.

      • removeJointMapping

        public void removeJointMapping()
        removes mapping of joint values

      • multiplyTransform

        public void multiplyTransform​(Transform3D parent,
                              State state,
                              Transform3D result)
        Post-multiply the transform of the frame to the parent transform.

        The transform is calculated for the joint values of state.

        The exact implementation of getTransform() depends on the type of
        frame. See for example RevoluteJoint and PrismaticJoint.

        Parameters:
        parent - [in] The world transform of the parent frame.
        state - [in] Joint values for the forward kinematics tree.
        result - [in] The transform of the frame in the world frame.

      • getTransform

        public Transform3D getTransform​(State state)
        The transform of the frame relative to its parent.

        The transform is calculated for the joint values of state.

        The exact implementation of getTransform() depends on the type of
        frame. See for example RevoluteJoint and PrismaticJoint.

        Parameters:
        state - [in] Joint values for the forward kinematics tree.

        Returns:
        The transform of the frame relative to its parent.

      • getDOF

        public int getDOF()
        The number of degrees of freedom (dof) of the frame.

        The dof is the number of joint values that are used for controlling
        the frame.

        Given a set joint values of type State, the getDof() number of joint
        values for the frame can be read and written with State::getQ() and
        State::setQ().

        Returns:
        The number of degrees of freedom of the frame.

      • getParent

        public Frame getParent()
        The parent of the frame or NULL if the frame is a DAF.

      • getParent

        public Frame getParent​(State state)
        Returns the parent of the frame

        If no static parent exists it look for at DAF parent. If such
        does not exists either it returns NULL.

        Parameters:
        state - [in] the state to consider
        Returns:
        the parent

      • getDafParent

        public Frame getDafParent​(State state)

      • getChildrenList

        public VectorFramePtr getChildrenList​(State state)
        get a list of all frame children
        Parameters:
        state - [in] the state of to look for children in.
        Returns:
        a vector with the children

      • attachTo

        public void attachTo​(FramePtr parent,
                     State state)
        Move a frame within the tree.

        The frame frame is detached from its parent and reattached to
        parent. The frames frame and parent must both belong to the
        same kinematics tree.

        Only frames with no static parent (see getParent()) can be moved.

        Parameters:
        parent - [in] The frame to attach frame to.
        state - [inout] The state to which the attachment is written.

      • isDAF

        public boolean isDAF()
        Test if this frame is a Dynamically Attachable Frame
        Returns:
        true if this frame is a DAF, false otherwise

      • wTf

        public Transform3D wTf​(State state)
        Get the transform relative to world.
        Parameters:
        state - [in] the state.
        Returns:
        transform relative to world.

      • fTf

        public Transform3D fTf​(FrameCPtr to,
                       State state)
        Get the transform of other frame relative to this frame.
        Parameters:
        to - [in] the other frame
        state - [in] the state.
        Returns:
        transform of frame to relative to this frame.

      • notEqual

        public boolean notEqual​(Frame rhs)
        Check if not equal
        Parameters:
        rhs - [in] the Frame to compare with
        Returns:
        true if not equal

      • toString

        public java.lang.String toString()
        Overrides:
        toString in class java.lang.Object

      • getID

        public int getID()
        An integer ID for the StateData.

        IDs are assigned to the state data upon insertion State.
        StateData that are not in a State have an ID of -1.

        StateData present in different trees may have identical IDs.

        IDs are used for the efficient implementation of State. Normally,
        you should not make use of StateData IDs yourself.

        Returns:
        An integer ID for the frame.

      • getName

        public java.lang.String getName()
        The name of the state data.

        Returns:
        The name of the state data.

      • size

        public int size()
        The number of doubles allocated by this StateData in
        each State object.

        Returns:
        The number of doubles allocated by the StateData

      • setData

        public void setData​(State state,
                    vector_d vals)
        Assign for state data the size() of values of the array
        vals.

        The array vals must be of length at least size().

        Parameters:
        state - [inout] The state to which vals are written.

        vals - [in] The joint values to assign.

        setData() and getData() are related as follows:
        data.setData(state, q_in); const double* q_out = data.getData(state); for (int i = 0; i < data.getDOF(); i++) q_in[i] == q_out[i];

      • setData

        public void setData​(State state,
                    double val)
        Assign for state data the size() of values of the array
        vals.

        The array vals must be of length at least size().

        Parameters:
        state - [inout] The state to which vals are written.



        setData() and getData() are related as follows:
        data.setData(state, q_in); const double* q_out = data.getData(state); for (int i = 0; i < data.getDOF(); i++) q_in[i] == q_out[i];

      • hasCache

        public boolean hasCache()
        Check is state data includes a cache.
        Returns:
        true if cache, false otherwise.

      • getCache

        public StateCachePtr getCache​(State state)
        Get the cache.
        Parameters:
        state - [in] the state.
        Returns:
        the cache.

      • getDefaultCache

        public StateCachePtr getDefaultCache()
        Get default cache.
        Returns:
        the cache.

      • setCache

        public void setCache​(StateCachePtr cache,
                     State state)
        Set the cache values.
        Parameters:
        cache - [in] the cache.
        state - [in/out] state updated with new cache.

      • getStateStructure

        public StateStructure getStateStructure()
        Get the state structure.
        Returns:
        the state structure.

      • getData

        public vector_d getData​(State state)
        An array of length size() containing the values for
        the state data.

        It is OK to call this method also for a StateData with zero size.

        Parameters:
        state - [in] The state containing the StateData values.

        Returns:
        The values for the frame.