Frame (Artisynth API documentation)

java.lang.Object
- artisynth.core.modelbase.ModelComponentBase
- - artisynth.core.modelbase.RenderableComponentBase
  - - artisynth.core.mechmodels.DynamicComponentBase
    - - artisynth.core.mechmodels.Frame

All Implemented Interfaces:

CollidableDynamicComponent, DynamicComponent, ForceEffector, FrameAttachable, MotionTargetComponent, PointAttachable, CopyableComponent, HasCoordinateFrame, ModelComponent, RenderableComponent, Traceable, TransformableGeometry, ScalableUnits, java.lang.Cloneable, HasProperties, HierarchyNode, HasRenderProps, IsRenderable, IsSelectable, Renderable, Scannable

Direct Known Subclasses:

FemModelFrame, RigidBody
```
public class Frame
extends DynamicComponentBase
implements TransformableGeometry, ScalableUnits, DynamicComponent, Traceable, MotionTargetComponent, CopyableComponent, HasCoordinateFrame, CollidableDynamicComponent, PointAttachable, FrameAttachable
```

Field Summary

Fields
Modifier and Type Field and Description

static boolean dynamicVelInWorldCoords

static PropertyList myProps

RigidTransform3d myRenderFrame
- Fields inherited from class artisynth.core.modelbase.ModelComponentBase
  enforceUniqueCompositeNames, enforceUniqueNames, myNumber, NULL_OBJ, useCompactPathNames
- Fields inherited from interface artisynth.core.modelbase.CopyableComponent
  COPY_REFERENCES
- Fields inherited from interface artisynth.core.modelbase.TransformableGeometry
  TG_ARTICULATED, TG_DRAGGER, TG_PRESERVE_ORIENTATION, TG_SIMULATING
- Fields inherited from interface maspack.render.IsRenderable
  TRANSPARENT, TWO_DIMENSIONAL

Fields
Modifier and Type	Field and Description
`static boolean`	`dynamicVelInWorldCoords`
`static PropertyList`	`myProps`
`RigidTransform3d`	`myRenderFrame`

Constructor Summary

Constructors
Constructor and Description

Frame()

Frame(RigidTransform3d X)

Constructors
Constructor and Description
`Frame()`
`Frame(RigidTransform3d X)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addEffectivePointMass(double m, Vector3d loc)` Adds a point mass to the effective spatial inertia for this Frame.
`void`	`addExternalForce(Wrench w)`
`void`	`addForce(Wrench w)`
`void`	`addPointForce(Point3d loc, Vector3d f)` Adds to this body's forces the wrench arising from applying a force `f` on a point `loc`.
`void`	`addPointForce(Wrench wr, Point3d loc, Vector3d f)` Adds to `wr` the wrench arising from applying a force `f` on a point `loc`.
`void`	`addPointMass(Matrix M, double m, Vector3d loc)` Adds a point mass to a matrix that contains the spatial inertia for this Frame.
`void`	`addPosImpulse(double[] xbuf, int xidx, double h, double[] vbuf, int vidx)`
`void`	`addPosJacobian(SparseNumberedBlockMatrix S, double s)` Scales the components of the position Jacobian associated with this force effector and adds it to the supplied solve matrix M.
`void`	`addScaledExternalForce(double s, Wrench w)`
`void`	`addSolveBlock(SparseNumberedBlockMatrix S)`
`void`	`addSolveBlocks(SparseNumberedBlockMatrix S)` Adds any needed blocks to a solve matrix in order to accomodate the Jacobian terms associated with this force effector.
`int`	`addTargetJacobian(SparseBlockMatrix J, int bi)` Add a row to the motion target Jacobian for this motion target.
`void`	`addToPointVelocity(Vector3d vel, double w, ContactPoint cpnt)` Computes the velocity imparted to a contact point by this component's current velocity, multiples it by a weighting factor `w`, and add it to `vel`.
`void`	`addTransformableDependencies(TransformGeometryContext context, int flags)` Adds to `context` any transformable components which should be transformed as the same time as this component.
`void`	`addVelJacobian(SparseNumberedBlockMatrix S, double s)` Scales the components of the velocity Jacobian associated with this force effector and adds it to the supplied solve matrix M.
`void`	`applyExternalForces()`
`void`	`applyForces(double t)` Adds forces to the components affected by this force effector at a particular time.
`void`	`applyGravity(Vector3d gacc)` Applies a gravity force to this component, given a prescribed gravity acceleration vector.
`void`	`computeAppliedWrench(Wrench wr, Vector3d f, Vector3d p)` Computes the wrench (in body coordinates) produced by applying a force at a particular point.
`void`	`computeLocalPointForceJacobian(MatrixBlock GT, Vector3d loc, RotationMatrix3d R)` Computes a force Jacobian for a point attached to this frame, and then optionally rotates its columns using a rotation matrix R.
`void`	`computePointCoriolis(Vector3d cor, Vector3d loc)` Computes the velocity derivative of a point attached to this frame that is due to the current velocity of the frame.
`void`	`computePointLocation(Vector3d loc, Vector3d pos)` Computes the location, in body coordinates, of a point whose position is given in world coordinates.
`void`	`computePointPosition(Vector3d pos, Point3d loc)` Computes the position, in world coordinates, of a point attached to this frame.
`void`	`computePointVelocity(Vector3d vel, Point3d loc)` Computes the velocity, in world coordinates, of a point attached to this frame.
`void`	`computePointVelocity(Vector3d vel, Point3d loc, Twist frameVel)` Computes the velocity, in world coordinates, of a point attached to this frame.
`void`	`computePointVelocity(Vector3d vel, Point3d loc, Vector3d pvel)` Computes the velocity, in world coordinates, of a point attached to this frame.
`void`	`computeWorldPointForceJacobian(MatrixBlock GT, Point3d loc)` Computes the force Jacobian, in world coordinates, for a point attached to this frame.
`Frame`	`copy(int flags, java.util.Map<ModelComponent,ModelComponent> copyMap)` Create a copy of this component.
`FrameFrameAttachment`	`createFrameAttachment(Frame frame, RigidTransform3d TFW)` Returns a FrameAttachment that attaches a `frame` to this component.
`MatrixBlock`	`createMassBlock()` Create a matrix block for representing the mass of this component, initialized to the component's effective mass (instrinsic mass plus the mass due to all attachmented components).
`PointFrameAttachment`	`createPointAttachment(Point pnt)` Returns a PointAttachment that attaches `pnt` to this component.
`RenderProps`	`createRenderProps()` Factory method to create render properties appropriate to this object.
`PropertyList`	`getAllPropertyInfo()` Returns a list giving static information about all properties exported by this object.
`double`	`getAxisLength()`
`void`	`getBodyForce(Wrench wr)`
`void`	`getBodyVelocity(Twist v)`
`int`	`getBodyVelState(double[] buf, int idx)`
`boolean`	`getCopyReferences(java.util.List<ModelComponent> refs, ModelComponent ancestor)` Collects external references which must also be copied in order to duplicate this component.
`void`	`getEffectiveMass(Matrix M, double t)` Gets the effective mass of this component at a particular time.
`int`	`getEffectiveMassForces(VectorNd f, double t, int idx)` Gets the mass forces for this component at a particular time.
`Wrench`	`getExternalForce()`
`Wrench`	`getForce()`
`int`	`getForce(double[] f, int idx)`
`void`	`getForce(Wrench wr)`
`double`	`getFrameDamping()`
`PropertyMode`	`getFrameDampingMode()`
`int`	`getJacobianType()` Returns a code indicating the matrix type that results when the Jacobian terms of this force effector are added to the solve matrix.
`double`	`getMass(double t)` Returns the scalar mass of this component at time t.
`void`	`getMass(Matrix M, double t)` Gets the mass of this component at a particular time.
`Vector3d`	`getMoment()`
`AxisAngle`	`getOrientation()`
`void`	`getOrientation(AxisAngle axisAng)`
`int`	`getPosDerivative(double[] dxdt, int idx)`
`RigidTransform3d`	`getPose()`
`void`	`getPose(RigidTransform3d XFrameToWorld)`
`Point3d`	`getPosition()`
`int`	`getPosState(double[] buf, int idx)`
`int`	`getPosStateSize()`
`double`	`getRotaryDamping()`
`PropertyMode`	`getRotaryDampingMode()`
`Quaternion`	`getRotation()`
`void`	`getSelection(java.util.LinkedList<java.lang.Object> list, int qid)` Append to `list` the component (or components) associated with the `qid`-th selection query issued by this component's render method.
`MotionTarget.TargetActivity`	`getTargetActivity()`
`AxisAngle`	`getTargetOrientation()`
`int`	`getTargetPos(double[] post, double s, double h, int idx)`
`RigidTransform3d`	`getTargetPose()`
`Point3d`	`getTargetPosition()`
`int`	`getTargetVel(double[] velt, double s, double h, int idx)`
`Twist`	`getTargetVelocity()`
`java.lang.String`	`getTraceablePositionProperty(java.lang.String traceableName)` For a given traceable property, returns the name of a property (if any) which provides a reference position to be used for the traceable property.
`java.lang.String[]`	`getTraceables()` Returns a list of all traceable properties in this Traceable.
`Vector3d`	`getTransForce()`
`Twist`	`getVelocity()`
`void`	`getVelocity(Twist v)`
`int`	`getVelState(double[] buf, int idx)`
`int`	`getVelStateSize()`
`int`	`getWorldVelState(double[] buf, int idx)`
`boolean`	`isDuplicatable()` Returns true if this component can be duplicated.
`boolean`	`isMassConstant()`
`int`	`mulInverseEffectiveMass(Matrix M, double[] a, double[] f, int idx)`
`void`	`prerender(RenderList list)` Called prior to rendering to allow this object to update the internal state required for rendering (such as by caching rendering coordinates).
`void`	`render(Renderer renderer, int flags)` Render this object using the functionality of the supplied `Renderer`.
`void`	`resetEffectiveMass()` Resets the effective mass of this component to the nominal mass.
`void`	`resetTargets()`
`void`	`scaleDistance(double s)` Scales all distance coordinates.
`void`	`scaleMass(double s)` Scales all mass units.
`void`	`setAxisLength(double len)`
`void`	`setBodyVelocity(Twist v)`
`void`	`setContactConstraint(double[] buf, double w, Vector3d dir, ContactPoint cpnt)` Computes the values for the block matrix which defines this component's contribution to a contact constraint matrix.
`void`	`setExternalForce(Wrench w)`
`int`	`setForce(double[] f, int idx)`
`void`	`setForce(Wrench w)`
`void`	`setFrameDamping(double d)`
`void`	`setFrameDampingMode(PropertyMode mode)`
`void`	`setOrientation(AxisAngle axisAng)`
`void`	`setPose(RigidTransform3d XFrameToWorld)`
`void`	`setPosition(Point3d pos)`
`int`	`setPosState(double[] buf, int idx)`
`void`	`setRotaryDamping(double d)`
`void`	`setRotaryDampingMode(PropertyMode mode)`
`void`	`setRotation(Quaternion q)`
`void`	`setState(Frame frame)`
`void`	`setTargetActivity(MotionTarget.TargetActivity activity)`
`void`	`setTargetOrientation(AxisAngle axisAng)`
`int`	`setTargetPos(double[] post, int idx)`
`void`	`setTargetPose(RigidTransform3d X)`
`void`	`setTargetPosition(Point3d pos)`
`int`	`setTargetVel(double[] velt, int idx)`
`void`	`setTargetVelocity(Twist vel)`
`void`	`setVelocity(double vx, double vy, double vz, double wx, double wy, double wz)`
`void`	`setVelocity(Twist v)`
`int`	`setVelState(double[] buf, int idx)`
`void`	`subPointForce(Point3d loc, Vector3d f)` Subtracts from this body's forces the wrench arising from applying a force `f` on a point `loc`.
`void`	`subPointForce(Wrench wr, Point3d loc, Vector3d f)` Subtracts from `wr` the wrench arising from applying a force `f` on a point `loc`.
`void`	`transformGeometry(GeometryTransformer gtr, TransformGeometryContext context, int flags)` Transforms the geometry of this component, using the geometry transformer `gtr` to transform its individual attributes.
`void`	`transformPose(RigidTransform3d T)`
`void`	`updateBounds(Vector3d pmin, Vector3d pmax)` Update the minimum and maximum points for this object.
`boolean`	`velocityLimitExceeded(double tlimit, double rlimit)` Checks if the current component velocity exceeds specified limits.
`void`	`zeroExternalForces()`
`void`	`zeroForces()`

Methods inherited from class artisynth.core.mechmodels.DynamicComponentBase
addConstrainer, addMasterAttachment, getAttachment, getConstrainers, getInverseMass, getMasterAttachments, getSolveIndex, hasState, isActive, isAttached, isControllable, isDynamic, isParametric, removeConstrainer, removeMasterAttachment, setAttached, setSolveIndex, transformGeometry

Methods inherited from class artisynth.core.modelbase.RenderableComponentBase
getRenderHints, getRenderProps, isSelectable, numSelectionQueriesNeeded, setRenderProps, updateRenderProps

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

Methods inherited from interface artisynth.core.mechmodels.DynamicComponent
addConstrainer, addMasterAttachment, checkFlag, clearFlag, getAttachment, getConstrainers, getInverseMass, getMasterAttachments, getSolveIndex, isActive, isAttached, isControllable, isDynamic, isParametric, removeConstrainer, removeMasterAttachment, setAttached, setFlag, setSolveIndex

Methods inherited from interface artisynth.core.modelbase.TransformableGeometry
transformGeometry

- Field Detail
  - dynamicVelInWorldCoords
```
public static boolean dynamicVelInWorldCoords
```
  - myRenderFrame
```
public RigidTransform3d myRenderFrame
```
  - myProps
```
public static PropertyList myProps
```
- Constructor Detail
  - Frame
```
public Frame()
```
  - Frame
```
public Frame(RigidTransform3d X)
```
- Method Detail
  - getAllPropertyInfo
```
public PropertyList getAllPropertyInfo()
```
    Description copied from interface: HasProperties
    
    Returns a list giving static information about all properties exported by this object.
    
    Specified by:
    
    getAllPropertyInfo in interface HasProperties
    
    Overrides:
    
    getAllPropertyInfo in class ModelComponentBase
    
    Returns:
    
    static information for all exported properties
  - getForce
```
public Wrench getForce()
```
  - getForce
```
public void getForce(Wrench wr)
```
  - getBodyForce
```
public void getBodyForce(Wrench wr)
```
  - getTransForce
```
public Vector3d getTransForce()
```
  - getMoment
```
public Vector3d getMoment()
```
  - setForce
```
public void setForce(Wrench w)
```
  - addForce
```
public void addForce(Wrench w)
```
  - getExternalForce
```
public Wrench getExternalForce()
```
  - setExternalForce
```
public void setExternalForce(Wrench w)
```
  - addExternalForce
```
public void addExternalForce(Wrench w)
```
  - addScaledExternalForce
```
public void addScaledExternalForce(double s,
                                   Wrench w)
```
  - getVelocity
```
public Twist getVelocity()
```
  - getVelocity
```
public void getVelocity(Twist v)
```
  - setVelocity
```
public void setVelocity(Twist v)
```
  - setVelocity
```
public void setVelocity(double vx,
                        double vy,
                        double vz,
                        double wx,
                        double wy,
                        double wz)
```
  - setPose
```
public void setPose(RigidTransform3d XFrameToWorld)
```
  - transformPose
```
public void transformPose(RigidTransform3d T)
```
  - getPose
```
public RigidTransform3d getPose()
```
  - getPose
```
public void getPose(RigidTransform3d XFrameToWorld)
```
    Specified by:
    
    getPose in interface HasCoordinateFrame
  - getPosition
```
public Point3d getPosition()
```
  - setPosition
```
public void setPosition(Point3d pos)
```
  - getOrientation
```
public AxisAngle getOrientation()
```
  - getOrientation
```
public void getOrientation(AxisAngle axisAng)
```
  - setOrientation
```
public void setOrientation(AxisAngle axisAng)
```
  - getRotation
```
public Quaternion getRotation()
```
  - setRotation
```
public void setRotation(Quaternion q)
```
  - applyGravity
```
public void applyGravity(Vector3d gacc)
```
    Applies a gravity force to this component, given a prescribed gravity acceleration vector.
    
    Specified by:
    
    applyGravity in interface DynamicComponent
  - getAxisLength
```
public double getAxisLength()
```
  - setAxisLength
```
public void setAxisLength(double len)
```
  - computePointPosition
```
public void computePointPosition(Vector3d pos,
                                 Point3d loc)
```
    Computes the position, in world coordinates, of a point attached to this frame.
    
    Parameters:
    
    pos - returns the point position
    
    loc - position of the point, in body coordinates
  - computePointLocation
```
public void computePointLocation(Vector3d loc,
                                 Vector3d pos)
```
    Computes the location, in body coordinates, of a point whose position is given in world coordinates. This is the inverse computation of computePointPosition(maspack.matrix.Vector3d, maspack.matrix.Point3d).
    
    Parameters:
    
    loc - returns the point location
    
    pos - position of the point, in world coordinates
  - computePointVelocity
```
public void computePointVelocity(Vector3d vel,
                                 Point3d loc)
```
    Computes the velocity, in world coordinates, of a point attached to this frame.
    
    Parameters:
    
    vel - returns the point velocity
    
    loc - position of the point, in body coordinates
  - addPointMass
```
public void addPointMass(Matrix M,
                         double m,
                         Vector3d loc)
```
    Adds a point mass to a matrix that contains the spatial inertia for this Frame.
    
    Parameters:
    
    M - matrix containing existing spatial inertia
    
    m - mass of the point
    
    loc - location of the point (in local frame coordinates)
  - computeWorldPointForceJacobian
```
public void computeWorldPointForceJacobian(MatrixBlock GT,
                                           Point3d loc)
```
    Computes the force Jacobian, in world coordinates, for a point attached to this frame. If the velocity state size (vsize) of this frame is 6, then GT should be an instance of Matrix6x3Block. Otherwise, it should be an instance of MatrixNdBlock with a size of vsize x 3. For the Matrix6x3Block case, the Jacobian is a 6x3 matrix with the following form:
```
 [     I     ]
 [           ]
 [ [ R loc ] ]
 
```
    where I is the 3x3 identity matrix, R is the frame orientation matrix, and [ x ] denotes the 3x3 skew-symmetric cross product matrix.
    Parameters:
    
    GT - returns the force Jacobian
    
    loc - position of the point, in body coordinates
  - computeLocalPointForceJacobian
```
public void computeLocalPointForceJacobian(MatrixBlock GT,
                                           Vector3d loc,
                                           RotationMatrix3d R)
```
    Computes a force Jacobian for a point attached to this frame, and then optionally rotates its columns using a rotation matrix R. If the velocity state size (vsize) of this frame is 6, then G should be an instance of Matrix6x3Block. Otherwise, it should be an instance of MatrixNdBlock with a size of vsize x 3. If the rotation matrix R is null, then the Jacobian takes the following form for the 6x3 matrix case:
```
 [     I       ]
 [             ]
 [ [ RF loc ]  ]
 
```
    where RF is the frame orientation matrix, loc is the location of the point in frame coordinates, and [ x ] denotes the 3x3 skew-symmetric cross product matrix. If the rotation matrix R is not null, then the 6x3 case takes the following form:
```
 [     R         ]
 [               ]
 [ [ RF loc ]  R ]
 
```
    Parameters:
    
    GT - returns the force Jacobian
    
    loc - location of the point, relative to the frame
    
    R - optional rotation transform
  - computePointVelocity
```
public void computePointVelocity(Vector3d vel,
                                 Point3d loc,
                                 Twist frameVel)
```
    Computes the velocity, in world coordinates, of a point attached to this frame.
    
    Parameters:
    
    vel - returns the point velocity
    
    loc - position of the point, in body coordinates
    
    frameVel - velocity of the frame, in rotated world coordinates
  - computePointVelocity
```
public void computePointVelocity(Vector3d vel,
                                 Point3d loc,
                                 Vector3d pvel)
```
    Computes the velocity, in world coordinates, of a point attached to this frame.
    
    Parameters:
    
    vel - returns the point velocity
    
    loc - position of the point, in body coordinates
    
    pvel - independent velocity for the point, in body coordinates
  - computePointCoriolis
```
public void computePointCoriolis(Vector3d cor,
                                 Vector3d loc)
```
    Computes the velocity derivative of a point attached to this frame that is due to the current velocity of the frame.
    
    Parameters:
    
    cor - returns the point Coriolis term (in world coordinates)
    
    loc - position of the point, in body coordinates
  - subPointForce
```
public void subPointForce(Wrench wr,
                          Point3d loc,
                          Vector3d f)
```
    Subtracts from wr the wrench arising from applying a force f on a point loc.
    
    Parameters:
    
    wr - wrench from which force is subtracted (world coordinates
    
    loc - location of the point (body coordinates)
    
    f - force acting on the point (world coordinates)
  - addPointForce
```
public void addPointForce(Wrench wr,
                          Point3d loc,
                          Vector3d f)
```
    Adds to wr the wrench arising from applying a force f on a point loc.
    
    Parameters:
    
    wr - wrench in which force is accumulated (world coordinates
    
    loc - location of the point (body coordinates)
    
    f - force applied to the point (world coordinates)
  - addPointForce
```
public void addPointForce(Point3d loc,
                          Vector3d f)
```
    Adds to this body's forces the wrench arising from applying a force f on a point loc.
    
    Parameters:
    
    loc - location of the point (body coordinates)
    
    f - force applied to the point (world coordinates)
  - subPointForce
```
public void subPointForce(Point3d loc,
                          Vector3d f)
```
    Subtracts from this body's forces the wrench arising from applying a force f on a point loc.
    
    Parameters:
    
    loc - location of the point (body coordinates)
    
    f - force applied to the point (world coordinates)
  - computeAppliedWrench
```
public void computeAppliedWrench(Wrench wr,
                                 Vector3d f,
                                 Vector3d p)
```
    Computes the wrench (in body coordinates) produced by applying a force at a particular point.
    
    Parameters:
    
    wr - returns the wrench in body coordinates
    
    f - applied force at the point (world coordinates)
    
    p - location of the point on the body (body coordinates)
  - resetTargets
```
public void resetTargets()
```
    Specified by:
    
    resetTargets in interface MotionTargetComponent
  - getTargetActivity
```
public MotionTarget.TargetActivity getTargetActivity()
```
    Specified by:
    
    getTargetActivity in interface MotionTargetComponent
  - setTargetActivity
```
public void setTargetActivity(MotionTarget.TargetActivity activity)
```
    Specified by:
    
    setTargetActivity in interface MotionTargetComponent
  - getTargetPosition
```
public Point3d getTargetPosition()
```
  - setTargetPosition
```
public void setTargetPosition(Point3d pos)
```
  - getTargetOrientation
```
public AxisAngle getTargetOrientation()
```
  - setTargetOrientation
```
public void setTargetOrientation(AxisAngle axisAng)
```
  - getTargetPose
```
public RigidTransform3d getTargetPose()
```
  - setTargetPose
```
public void setTargetPose(RigidTransform3d X)
```
  - getTargetVelocity
```
public Twist getTargetVelocity()
```
  - setTargetVelocity
```
public void setTargetVelocity(Twist vel)
```
  - getTargetVel
```
public int getTargetVel(double[] velt,
                        double s,
                        double h,
                        int idx)
```
    Specified by:
    
    getTargetVel in interface MotionTargetComponent
  - setTargetVel
```
public int setTargetVel(double[] velt,
                        int idx)
```
    Specified by:
    
    setTargetVel in interface MotionTargetComponent
  - getTargetPos
```
public int getTargetPos(double[] post,
                        double s,
                        double h,
                        int idx)
```
    Specified by:
    
    getTargetPos in interface MotionTargetComponent
  - setTargetPos
```
public int setTargetPos(double[] post,
                        int idx)
```
    Specified by:
    
    setTargetPos in interface MotionTargetComponent
  - addTargetJacobian
```
public int addTargetJacobian(SparseBlockMatrix J,
                             int bi)
```
    Description copied from interface: MotionTargetComponent
    Add a row to the motion target Jacobian for this motion target. The Jacobian maps state velocities u into motion target velocities vt according to
```
 vt = J u
 
```
    Specified by:
    
    addTargetJacobian in interface MotionTargetComponent
    
    Parameters:
    
    J - motion target Jacobian
    
    bi - block row index for the row to be added
    
    Returns:
    
    bi + 1
  - getFrameDamping
```
public double getFrameDamping()
```
  - setFrameDamping
```
public void setFrameDamping(double d)
```
  - getFrameDampingMode
```
public PropertyMode getFrameDampingMode()
```
  - setFrameDampingMode
```
public void setFrameDampingMode(PropertyMode mode)
```
  - getRotaryDamping
```
public double getRotaryDamping()
```
  - setRotaryDamping
```
public void setRotaryDamping(double d)
```
  - getRotaryDampingMode
```
public PropertyMode getRotaryDampingMode()
```
  - setRotaryDampingMode
```
public void setRotaryDampingMode(PropertyMode mode)
```
  - createRenderProps
```
public RenderProps createRenderProps()
```
    Description copied from interface: HasRenderProps
    
    Factory method to create render properties appropriate to this object.
    
    Specified by:
    
    createRenderProps in interface HasRenderProps
    
    Overrides:
    
    createRenderProps in class RenderableComponentBase
    
    Returns:
    
    new render properties for this object
  - prerender
```
public void prerender(RenderList list)
```
    Description copied from interface: IsRenderable
    
    Called prior to rendering to allow this object to update the internal state required for rendering (such as by caching rendering coordinates). The object may add internal objects to the list of objects being rendered, by calling
    list.addIfVisible (obj);
    for each of the objects in question.
    
    Specified by:
    
    prerender in interface IsRenderable
    
    Overrides:
    
    prerender in class RenderableComponentBase
    
    Parameters:
    
    list - list of objects to be rendered
  - updateBounds
```
public void updateBounds(Vector3d pmin,
                         Vector3d pmax)
```
    Description copied from interface: IsRenderable
    
    Update the minimum and maximum points for this object. In an x-y-z coordinate system with x directed to the right and y directed upwards, the minimum and maximum points can be thought of as defining the left-lower-far and right-upper-near corners of a bounding cube. This method should only reduce the elements of the minimum point and increase the elements of the maximum point, since it may be used as part of an iteration to determine the bounding cube for several different objects.
    
    Specified by:
    
    updateBounds in interface IsRenderable
    
    Overrides:
    
    updateBounds in class RenderableComponentBase
    
    Parameters:
    
    pmin - minimum point
    
    pmax - maximum point
  - render
```
public void render(Renderer renderer,
                   int flags)
```
    Description copied from interface: IsRenderable
    
    Render this object using the functionality of the supplied Renderer.
    
    Specified by:
    
    render in interface IsRenderable
    
    Specified by:
    
    render in class RenderableComponentBase
    
    Parameters:
    
    renderer - provides the functionality used to perform the rendering.
    
    flags - flags that may be used to control different aspects of the rendering. Flags are defined in Renderer and currently include Renderer.HIGHLIGHT and Renderer.SORT_FACES.
  - getSelection
```
public void getSelection(java.util.LinkedList<java.lang.Object> list,
                         int qid)
```
    Description copied from interface: IsSelectable
    
    Append to list the component (or components) associated with the qid-th selection query issued by this component's render method. This will only be called if this component manages its own selection (i.e., the number nums returned by IsSelectable.numSelectionQueriesNeeded() is positive), and qid will in turn be a number between 0 and nums-1.
    
    Specified by:
    
    getSelection in interface IsSelectable
    
    Overrides:
    
    getSelection in class RenderableComponentBase
    
    Parameters:
    
    list - selected objects are appended to the end of this list
    
    qid - index of the selection query
  - transformGeometry
```
public void transformGeometry(GeometryTransformer gtr,
                              TransformGeometryContext context,
                              int flags)
```
    Description copied from interface: TransformableGeometry
    
    Transforms the geometry of this component, using the geometry transformer gtr to transform its individual attributes. The context argument supplies information about what other components are currently being transformed, and also allows the requesting of update actions to be performed after all transform called have completed. The context is also the usual entity that calls this method, from within its TransformGeometryContext.apply(maspack.geometry.GeometryTransformer, int) method. The argument flags provides flags to specify various conditions associated with the the transformation. At present, the available flags are TransformableGeometry.TG_SIMULATING and TransformableGeometry.TG_ARTICULATED.
    This method is not usually called directly by applications. Instead, it is typically called from within the TransformGeometryContext.apply(maspack.geometry.GeometryTransformer, int) method of the context, which takes care of the various operations needed for a complete transform operation, including calling TransformableGeometry.addTransformableDependencies(artisynth.core.modelbase.TransformGeometryContext, int) to collect other components that should be transformed, calling TransformableGeometry.transformGeometry(maspack.matrix.AffineTransform3dBase) for each component, notifying component parents that the geometry has changed, and calling any requested TransformGeometryActions. More details are given in the documentation for TransformGeometryContext.apply(maspack.geometry.GeometryTransformer, int).
    TransformGeometryContext provides a number of static convenience transform methods which take care of building the context and calling apply() for a specified set of components.
    This method should not generally call transformGeometry() for its descendant components. Instead, descendants needing transformation should be specified by adding them to the context in the method TransformableGeometry.addTransformableDependencies(artisynth.core.modelbase.TransformGeometryContext, int).
    
    Specified by:
    
    transformGeometry in interface TransformableGeometry
    
    Overrides:
    
    transformGeometry in class DynamicComponentBase
    
    Parameters:
    
    gtr - transformer implementing the transform
    
    context - context information, including what other components are being transformed
    
    flags - specifies conditions associated with the transformation
  - addTransformableDependencies
```
public void addTransformableDependencies(TransformGeometryContext context,
                                         int flags)
```
    Description copied from interface: TransformableGeometry
    
    Adds to context any transformable components which should be transformed as the same time as this component. This will generally include descendant components, and may also include other components to which this component is connected in some way.
    This method is generally called from with the TransformGeometryContext.apply(maspack.geometry.GeometryTransformer, int) method of a TransformGeometryContext.
    
    Specified by:
    
    addTransformableDependencies in interface TransformableGeometry
    
    Overrides:
    
    addTransformableDependencies in class DynamicComponentBase
    
    Parameters:
    
    context - context information, to which the dependent components are added.
    
    flags - specifies conditions associated with the transformation
  - scaleDistance
```
public void scaleDistance(double s)
```
    Description copied from interface: ScalableUnits
    
    Scales all distance coordinates.
    
    Specified by:
    
    scaleDistance in interface ScalableUnits
    
    Parameters:
    
    s - scaling factor
  - zeroExternalForces
```
public void zeroExternalForces()
```
    Specified by:
    
    zeroExternalForces in interface DynamicComponent
  - zeroForces
```
public void zeroForces()
```
    Specified by:
    
    zeroForces in interface DynamicComponent
  - applyExternalForces
```
public void applyExternalForces()
```
    Specified by:
    
    applyExternalForces in interface DynamicComponent
  - applyForces
```
public void applyForces(double t)
```
    Description copied from interface: ForceEffector
    
    Adds forces to the components affected by this force effector at a particular time. Component forces should be added and not set, since other forces may be added to the same components by other force effectors.
    
    Specified by:
    
    applyForces in interface ForceEffector
    
    Parameters:
    
    t - time (seconds)
  - addVelJacobian
```
public void addVelJacobian(SparseNumberedBlockMatrix S,
                           double s)
```
    Description copied from interface: ForceEffector
    
    Scales the components of the velocity Jacobian associated with this force effector and adds it to the supplied solve matrix M.
    M is guaranteed to be the same matrix supplied in the most recent call to addSolveBlocks, and so implementations may choose to cache the relevant matrix blocks from that call, instead of retrieving them directly from M.
    
    Specified by:
    
    addVelJacobian in interface ForceEffector
    
    Parameters:
    
    S - solve matrix to which scaled velocity Jacobian is to be added
    
    s - scaling factor for velocity Jacobian
  - addPosJacobian
```
public void addPosJacobian(SparseNumberedBlockMatrix S,
                           double s)
```
    Description copied from interface: ForceEffector
    
    Scales the components of the position Jacobian associated with this force effector and adds it to the supplied solve matrix M.
    M is guaranteed to be the same matrix supplied in the most recent call to addSolveBlocks, and so implementations may choose to cache the relevant matrix blocks from that call, instead of retrieving them directly from M.
    
    Specified by:
    
    addPosJacobian in interface ForceEffector
    
    Parameters:
    
    S - solve matrix to which scaled position Jacobian is to be added
    
    s - scaling factor for position Jacobian
  - addSolveBlocks
```
public void addSolveBlocks(SparseNumberedBlockMatrix S)
```
    Description copied from interface: ForceEffector
    
    Adds any needed blocks to a solve matrix in order to accomodate the Jacobian terms associated with this force effector. In general, blocks will be need to be added at locations given by the block indices (bi, bj), where bi and bj correspond to the solve indices (as returned by getSolveIndex) for all dynamic or attached components affected by this force effector.
    
    Specified by:
    
    addSolveBlocks in interface ForceEffector
    
    Parameters:
    
    S - solve matrix to which blocks should be added
  - getJacobianType
```
public int getJacobianType()
```
    Description copied from interface: ForceEffector
    
    Returns a code indicating the matrix type that results when the Jacobian terms of this force effector are added to the solve matrix. This should be a logical or-ing of either Matrix.SYMMETRIC or Matrix.POSITIVE_DEFINITE. The former should be set if adding the Jacobian terms preserves symmetry, and the latter should be set if positive definiteness if preserved. Both should be set if there is no Jacobian for this effector (i.e., the Jacobian methods are not implemented). Matrix types from all the force effectors are logically and-ed together to determine the type for the entire solve matrix.
    
    Specified by:
    
    getJacobianType in interface ForceEffector
    
    Returns:
    
    solve matrix type resulting from adding Jacobian terms
  - scaleMass
```
public void scaleMass(double s)
```
    Description copied from interface: ScalableUnits
    
    Scales all mass units.
    
    Specified by:
    
    scaleMass in interface ScalableUnits
    
    Parameters:
    
    s - scaling factor
  - createMassBlock
```
public MatrixBlock createMassBlock()
```
    Description copied from interface: DynamicComponent
    
    Create a matrix block for representing the mass of this component, initialized to the component's effective mass (instrinsic mass plus the mass due to all attachmented components).
    
    Specified by:
    
    createMassBlock in interface DynamicComponent
  - isMassConstant
```
public boolean isMassConstant()
```
    Specified by:
    
    isMassConstant in interface DynamicComponent
  - getMass
```
public double getMass(double t)
```
    Description copied from interface: DynamicComponent
    
    Returns the scalar mass of this component at time t.
    
    Specified by:
    
    getMass in interface DynamicComponent
  - getMass
```
public void getMass(Matrix M,
                    double t)
```
    Description copied from interface: DynamicComponent
    
    Gets the mass of this component at a particular time. Not currently used; getEffectiveMass() is used instead.
    
    Specified by:
    
    getMass in interface DynamicComponent
    
    Parameters:
    
    M - matrix to return the mass in
    
    t - current time
  - getEffectiveMass
```
public void getEffectiveMass(Matrix M,
                             double t)
```
    Description copied from interface: DynamicComponent
    
    Gets the effective mass of this component at a particular time. The effective mass is the nominal mass plus any additional mass incurred from attached components.
    
    Specified by:
    
    getEffectiveMass in interface DynamicComponent
    
    Parameters:
    
    M - matrix to return the mass in
    
    t - current time
  - mulInverseEffectiveMass
```
public int mulInverseEffectiveMass(Matrix M,
                                   double[] a,
                                   double[] f,
                                   int idx)
```
    Specified by:
    
    mulInverseEffectiveMass in interface DynamicComponent
  - resetEffectiveMass
```
public void resetEffectiveMass()
```
    Description copied from interface: DynamicComponent
    
    Resets the effective mass of this component to the nominal mass.
    
    Specified by:
    
    resetEffectiveMass in interface DynamicComponent
  - addEffectivePointMass
```
public void addEffectivePointMass(double m,
                                  Vector3d loc)
```
    Adds a point mass to the effective spatial inertia for this Frame.
    
    Parameters:
    
    m - mass of the point
    
    loc - location of the point (in local frame coordinates)
  - getEffectiveMassForces
```
public int getEffectiveMassForces(VectorNd f,
                                  double t,
                                  int idx)
```
    Description copied from interface: DynamicComponent
    
    Gets the mass forces for this component at a particular time. The forces should be stored in f, starting at the location specified by idx. Upon return, this method should return the value of idx incremented by the dimension of the mass forces.
    
    Specified by:
    
    getEffectiveMassForces in interface DynamicComponent
    
    Parameters:
    
    f - vector to return the forces in
    
    t - current time
    
    idx - starting location within f where forces should be stored
    
    Returns:
    
    updated value for idx
  - addSolveBlock
```
public void addSolveBlock(SparseNumberedBlockMatrix S)
```
    Specified by:
    
    addSolveBlock in interface DynamicComponent
    
    Specified by:
    
    addSolveBlock in class DynamicComponentBase
  - setState
```
public void setState(Frame frame)
```
  - getPosState
```
public int getPosState(double[] buf,
                       int idx)
```
    Specified by:
    
    getPosState in interface DynamicComponent
  - setPosState
```
public int setPosState(double[] buf,
                       int idx)
```
    Specified by:
    
    setPosState in interface DynamicComponent
  - addPosImpulse
```
public void addPosImpulse(double[] xbuf,
                          int xidx,
                          double h,
                          double[] vbuf,
                          int vidx)
```
    Specified by:
    
    addPosImpulse in interface DynamicComponent
  - getPosDerivative
```
public int getPosDerivative(double[] dxdt,
                            int idx)
```
    Specified by:
    
    getPosDerivative in interface DynamicComponent
  - getVelState
```
public int getVelState(double[] buf,
                       int idx)
```
    Specified by:
    
    getVelState in interface DynamicComponent
  - getBodyVelState
```
public int getBodyVelState(double[] buf,
                           int idx)
```
  - getWorldVelState
```
public int getWorldVelState(double[] buf,
                            int idx)
```
  - setVelState
```
public int setVelState(double[] buf,
                       int idx)
```
    Specified by:
    
    setVelState in interface DynamicComponent
  - setForce
```
public int setForce(double[] f,
                    int idx)
```
    Specified by:
    
    setForce in interface DynamicComponent
  - getForce
```
public int getForce(double[] f,
                    int idx)
```
    Specified by:
    
    getForce in interface DynamicComponent
  - copy
```
public Frame copy(int flags,
                  java.util.Map<ModelComponent,ModelComponent> copyMap)
```
    Description copied from interface: CopyableComponent
    
    Create a copy of this component. If COPY_REFERENCES is set in flags, then any component referenced by this component should itself be set to a copy. This should be done first checking copyMap for an existing copy of the referenced component. If there is no existing copy, then a copy should be created by calling copy recursively and adding the new copy to copyMap.
    
    Specified by:
    
    copy in interface CopyableComponent
    
    Overrides:
    
    copy in class DynamicComponentBase
    
    Parameters:
    
    flags - flags to control the copying
    
    copyMap - map to possible existing instances of referenced components
    
    Returns:
    
    copy of this component
  - setBodyVelocity
```
public void setBodyVelocity(Twist v)
```
  - getBodyVelocity
```
public void getBodyVelocity(Twist v)
```
  - getTraceables
```
public java.lang.String[] getTraceables()
```
    Returns a list of all traceable properties in this Traceable.
    
    Specified by:
    
    getTraceables in interface Traceable
  - getTraceablePositionProperty
```
public java.lang.String getTraceablePositionProperty(java.lang.String traceableName)
```
    For a given traceable property, returns the name of a property (if any) which provides a reference position to be used for the traceable property. The property name can be prepended with either a + or - character, which is used to control the rendering of the tracing probe in case the traceable property is a 3-vector. A prepended + character means that the vector will be rendered starting at, and directed away from the reference position (or render as pull), while a + character means that the vector will be rendered starting away from, and directed into the reference position (or render as push).
    
    Specified by:
    
    getTraceablePositionProperty in interface Traceable
    
    Returns:
    
    reference position property name, or null.
  - createPointAttachment
```
public PointFrameAttachment createPointAttachment(Point pnt)
```
    Description copied from interface: PointAttachable
    
    Returns a PointAttachment that attaches pnt to this component. It should not be assumed that pnt is currently connected to the component hierarchy, and no attempt should be made to connect the returned attachment to the hierarchy; the latter, if desired, is the responsibility of the caller.
    In some cases, it may not be possible to attach the point at its present location. In that case, the method will create an attachment to the nearest feasible location.
    
    Specified by:
    
    createPointAttachment in interface PointAttachable
    
    Parameters:
    
    pnt - point for which an attachment should be created
    
    Returns:
    
    attachment connecting pnt to this component
  - createFrameAttachment
```
public FrameFrameAttachment createFrameAttachment(Frame frame,
                                                  RigidTransform3d TFW)
```
    Description copied from interface: FrameAttachable
    
    Returns a FrameAttachment that attaches a frame to this component. Once attached the frame will follow the body around. The initial pose of the frame is specified by TFW, which gives its position and orientation in world coordinates. If TFW is null, then the current pose of the frame is used. If frame is null, then a virtual attachment is created at the initial pose specified by TFW. frame and TFW cannot both be null.
    In some cases, it may not be possible to attach the frame at the requested location. In that case, the method will relocate the frame to the nearest feasible attachment location.
    
    Specified by:
    
    createFrameAttachment in interface FrameAttachable
    
    Parameters:
    
    frame - frame to be attached
    
    TFW - transform from (initial) frame coordinates to world coordinates
    
    Returns:
    
    attachment connecting frame to this component
  - getVelStateSize
```
public int getVelStateSize()
```
    Specified by:
    
    getVelStateSize in interface DynamicComponent
    
    Specified by:
    
    getVelStateSize in interface MotionTargetComponent
  - getPosStateSize
```
public int getPosStateSize()
```
    Specified by:
    
    getPosStateSize in interface DynamicComponent
    
    Specified by:
    
    getPosStateSize in interface MotionTargetComponent
  - velocityLimitExceeded
```
public boolean velocityLimitExceeded(double tlimit,
                                     double rlimit)
```
    Checks if the current component velocity exceeds specified limits. Used to check solution stability.
    
    Specified by:
    
    velocityLimitExceeded in interface DynamicComponent
    
    Parameters:
    
    tlimit - translational velocity limit
    
    rlimit - rotational velocity limit
    
    Returns:
    
    true if velocity exceeds specified limits
  - isDuplicatable
```
public boolean isDuplicatable()
```
    Description copied from interface: CopyableComponent
    
    Returns true if this component can be duplicated. Duplication means that we can expect to be able to make a complete copy of the component along with all it's external references. This method should return true if and only if CopyableComponent.getCopyReferences(java.util.List<artisynth.core.modelbase.ModelComponent>, artisynth.core.modelbase.ModelComponent) returns true.
    This method is not currently used. It is intended to provide a faster way of determining if a component can be duplicated, without having to use CopyableComponent.getCopyReferences(java.util.List<artisynth.core.modelbase.ModelComponent>, artisynth.core.modelbase.ModelComponent) to build the list of copy references.
    
    Specified by:
    
    isDuplicatable in interface CopyableComponent
    
    Returns:
    
    true if this component can be duplicated.
  - getCopyReferences
```
public boolean getCopyReferences(java.util.List<ModelComponent> refs,
                                 ModelComponent ancestor)
```
    Description copied from interface: CopyableComponent
    
    Collects external references which must also be copied in order to duplicate this component. These references should exclude those which are contained within a specified component hierarchy. This method should return true if and only if CopyableComponent.isDuplicatable() returns true.
    
    Specified by:
    
    getCopyReferences in interface CopyableComponent
    
    Parameters:
    
    refs - list to which references are appended
    
    ancestor - root node of the hierarchy from which references are to be excluded
    
    Returns:
    
    false if it is discovered that the component cannot be duplicated
  - setContactConstraint
```
public void setContactConstraint(double[] buf,
                                 double w,
                                 Vector3d dir,
                                 ContactPoint cpnt)
```
    Description copied from interface: CollidableDynamicComponent
    
    Computes the values for the block matrix which defines this component's contribution to a contact constraint matrix. The matrix is 1 x n, where n is the component's velocity state size, and the contact is defined by a direction dir and a point cpnt. The computed values should be scaled by a weighting factor w.
    
    Specified by:
    
    setContactConstraint in interface CollidableDynamicComponent
    
    Parameters:
    
    buf - returns the n values for the block matrix
    
    w - weighting factor by which the values should be scaled
    
    dir - contact direction (world coordinates)
    
    cpnt - contact point
  - addToPointVelocity
```
public void addToPointVelocity(Vector3d vel,
                               double w,
                               ContactPoint cpnt)
```
    Description copied from interface: CollidableDynamicComponent
    
    Computes the velocity imparted to a contact point by this component's current velocity, multiples it by a weighting factor w, and add it to vel.
    
    Specified by:
    
    addToPointVelocity in interface CollidableDynamicComponent
    
    Parameters:
    
    vel - accumulates contact point velocity (world coordinates)
    
    w - weighting factor
    
    cpnt - contact point

Class Frame

Field Summary

Fields inherited from class artisynth.core.modelbase.ModelComponentBase

Fields inherited from interface artisynth.core.modelbase.CopyableComponent

Fields inherited from interface artisynth.core.modelbase.TransformableGeometry

Fields inherited from interface maspack.render.IsRenderable

Constructor Summary

Method Summary

Methods inherited from class artisynth.core.mechmodels.DynamicComponentBase

Methods inherited from class artisynth.core.modelbase.RenderableComponentBase

Methods inherited from class artisynth.core.modelbase.ModelComponentBase

Methods inherited from class java.lang.Object

Methods inherited from interface artisynth.core.mechmodels.DynamicComponent

Methods inherited from interface artisynth.core.modelbase.TransformableGeometry

Field Detail

dynamicVelInWorldCoords

myRenderFrame

myProps

Constructor Detail

Frame

Frame

Method Detail

getAllPropertyInfo

getForce

getForce

getBodyForce

getTransForce

getMoment

setForce

addForce

getExternalForce

setExternalForce

addExternalForce

addScaledExternalForce

getVelocity

getVelocity

setVelocity

setVelocity

setPose

transformPose

getPose

getPose

getPosition

setPosition

getOrientation

getOrientation

setOrientation

getRotation

setRotation

applyGravity

getAxisLength

setAxisLength

computePointPosition

computePointLocation

computePointVelocity

addPointMass

computeWorldPointForceJacobian

computeLocalPointForceJacobian

computePointVelocity

computePointVelocity

computePointCoriolis

subPointForce

addPointForce

addPointForce

subPointForce

computeAppliedWrench

resetTargets

getTargetActivity

setTargetActivity

getTargetPosition

setTargetPosition

getTargetOrientation

setTargetOrientation

getTargetPose

setTargetPose

getTargetVelocity

setTargetVelocity

getTargetVel

setTargetVel

getTargetPos