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, ContactMaster, DynamicAgent, DynamicComponent, ForceEffector, FrameAttachable, MotionTargetComponent, PointAttachable, CopyableComponent, HasCoordinateFrame, HasNumericState, ModelComponent, PostScannable, RenderableComponent, Traceable, TransformableGeometry, ScalableUnits, java.lang.Cloneable, HasProperties, HierarchyNode, HasRenderProps, IsRenderable, IsSelectable, Renderable, Scannable

Direct Known Subclasses:

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

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, REST_POSITION
- 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 Deprecated Methods
Modifier and Type	Method and Description
`void`	`add1DConstraintBlocks(SparseBlockMatrix GT, int bj, double scale, ContactPoint cpnt, Vector3d dir)` Adds blocks to the constraint matrix GT to implement a 1D constraint in a specified direction.
`void`	`add2DConstraintBlocks(SparseBlockMatrix GT, int bj, double scale, ContactPoint cpnt, Vector3d dir0, Vector3d dir1)` Adds blocks to the constraint matrix GT to implement a 2D constraint in two specified directions.
`void`	`addEffectiveFrameMass(SpatialInertia M, RigidTransform3d TFL0)` Adds a frame inertia to the effective spatial inertia for this Frame.
`void`	`addEffectivePointMass(double m, Vector3d loc)` Adds a point mass to the effective spatial inertia for this Frame.
`void`	`addExternalForce(Wrench w)`
`int`	`addForce(double[] f, int idx)`
`void`	`addForce(Wrench w)`
`void`	`addFrameForce(RigidTransform3d TFL, Wrench wr)` Adds to this body's forces the wrench arising from applying a wrench `f` on an attached frame.
`void`	`addPointForce(Point3d loc, Vector3d f)` Adds to this body's forces the wrench arising from applying a force `f` on an attached point.
`void`	`addPointForce(Wrench wr, Point3d loc, Vector3d f)` Adds to `wr` the wrench arising from applying a force `f` on a point `loc`.
`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`	`addRelativeVelocity(Vector3d vel, double scale, ContactPoint cpnt)` Accumulate the velocity at the contact due to the current velocity of the underlying dynamic components.
`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.
`int`	`collectMasterComponents(java.util.HashSet<DynamicComponent> masters, boolean activeOnly)` Collects all the underlying dynamic ``master'' components.
`void`	`computeAppliedWrench(Wrench wr, Vector3d f, Vector3d p)` Deprecated.
`void`	`computeForceOnMasters(VectorNd uvec, Vector3d fc, double scale, ContactPoint cpnt, SparseBlockMatrix S)` XXX Experimental XXX Compute the forces on the masters resulting from a force fc applied at the contact point, and accumulate them in uvec, whose size should equal that of the system forces.
`void`	`computeFrameLocation(RigidTransform3d TFL, RigidTransform3d TFW)`
`void`	`computeFramePosition(RigidTransform3d TFW, RigidTransform3d TFL)`
`void`	`computeFramePosVel(RigidTransform3d TFW, Twist vel, MatrixBlock J, Twist dv, RigidTransform3d TFL)`
`void`	`computeFrameVelocity(Twist vel, RigidTransform3d TFL)`
`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`	`computePointPosVel(Point3d pos, Vector3d vel, MatrixBlock J, Vector3d dv, Point3d loc)`
`void`	`computePointVelocity(Vector3d vel, Vector3d loc)` Computes the velocity, in world coordinates, of 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.
`Renderer.AxisDrawStyle`	`getAxisDrawStyle()`
`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.
`double`	`getEffectiveMass()` Gets the effective scalar mass of 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()`
`FrameMarker[]`	`getFrameMarkers()` Returns an array of all FrameMarkers currently associated with this rigid body.
`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()`
`RigidTransform3d`	`getRenderFrame()` Returns the cached copy of this frame's pose that should be used for rendering.
`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.
`void`	`getState(DataBuffer data)` Saves state information for this component by adding data to the supplied DataBuffer.
`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`	`hasForce()` Queries whether or not this component actually exerts its own state-dependent forces (typically associated with damping).
`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`	`setAxisDrawStyle(Renderer.AxisDrawStyle style)`
`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`	`setRandomForce()` Sets the force of this component to a random value.
`void`	`setRandomPosState()` Sets the position state of this component to a random value.
`void`	`setRandomVelState()` Sets the velocity state of this component to a random value.
`void`	`setRotaryDamping(double d)`
`void`	`setRotaryDampingMode(PropertyMode mode)`
`void`	`setRotation(Quaternion q)`
`void`	`setState(DataBuffer data)` Restores the state for this component by reading from the supplied data buffer, starting at the current buffer offsets.
`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`	`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`	`updateAttachmentPosStates()` Update the state of any dynamic components which are attached to this frame.
`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
addAttachmentRequest, addConstrainer, addMasterAttachment, connectToHierarchy, disconnectFromHierarchy, getAttachment, getConstrainers, getInverseMass, getMasterAttachments, getSolveIndex, hasState, isActive, isAttached, isControllable, isDynamic, isParametric, removeAttachmentRequest, removeConstrainer, removeMasterAttachment, setAttached, setSolveIndex, transformGeometry

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

Methods inherited from class artisynth.core.modelbase.ModelComponentBase
checkFlag, checkName, checkNameUniqueness, clearFlag, clone, createTempFlag, getChildren, getGrandParent, getHardReferences, getName, getNameRange, getNavpanelVisibility, getNavpanelVisibility, getNumber, getParent, getProperty, getSoftReferences, hasChildren, isFixed, isMarked, isScanning, isSelected, isWritable, makeValidName, makeValidName, notifyParentOfChange, postscan, printReferences, recursivelyContained, recursivelyContains, removeTempFlag, scan, setFixed, setFlag, setMarked, setName, setNavpanelVisibility, setNavpanelVisibility, setNumber, setParent, setScanning, setSelected, setWritable, updateReferences, write

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

Methods inherited from interface artisynth.core.mechmodels.DynamicComponent
addAttachmentRequest, removeAttachmentRequest

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

Methods inherited from interface artisynth.core.modelbase.HasNumericState
advanceState, getAuxVarDerivative, getAuxVarState, getStateVersion, hasState, numAuxVars, requiresAdvance, setAuxVarState

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

Methods inherited from interface artisynth.core.mechmodels.ContactMaster
isControllable

- 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 RenderableComponentBase
    
    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 DynamicAgent
  - getAxisLength
```
public double getAxisLength()
```
  - setAxisLength
```
public void setAxisLength(double len)
```
  - getAxisDrawStyle
```
public Renderer.AxisDrawStyle getAxisDrawStyle()
```
  - setAxisDrawStyle
```
public void setAxisDrawStyle(Renderer.AxisDrawStyle style)
```
  - 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,
                                 Vector3d 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
  - computePointPosVel
```
public void computePointPosVel(Point3d pos,
                               Vector3d vel,
                               MatrixBlock J,
                               Vector3d dv,
                               Point3d loc)
```
  - computeFramePosition
```
public void computeFramePosition(RigidTransform3d TFW,
                                 RigidTransform3d TFL)
```
  - computeFrameLocation
```
public void computeFrameLocation(RigidTransform3d TFL,
                                 RigidTransform3d TFW)
```
  - computeFrameVelocity
```
public void computeFrameVelocity(Twist vel,
                                 RigidTransform3d TFL)
```
  - computeFramePosVel
```
public void computeFramePosVel(RigidTransform3d TFW,
                               Twist vel,
                               MatrixBlock J,
                               Twist dv,
                               RigidTransform3d TFL)
```
  - 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
  - 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 an attached point.
    
    Parameters:
    
    loc - location of the point (body coordinates)
    
    f - force applied to the point (world coordinates)
  - addFrameForce
```
public void addFrameForce(RigidTransform3d TFL,
                          Wrench wr)
```
    Adds to this body's forces the wrench arising from applying a wrench f on an attached frame.
    
    Parameters:
    
    TFL - location of the frame with respect to the body
    
    wr - 6 DOF force applied to the frame (world coordinates)
  - computeAppliedWrench
```
public void computeAppliedWrench(Wrench wr,
                                 Vector3d f,
                                 Vector3d p)
```
    Deprecated.
    
    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)
```
  - 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)
```
  - 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)
```
  - hasForce
```
public boolean hasForce()
```
    Description copied from interface: DynamicAgent
    
    Queries whether or not this component actually exerts its own state-dependent forces (typically associated with damping). If it does not, then the component makes no contribution to its stiffness and damping matrices, a fact that can be exploited to improve the efficiency of the physics solve.
    Any action that alters the return value of this method should propagate a StructureChangeEvent. This can be a state-not-changed event if component's state structure is not altered (which it typically won't be).
    
    Specified by:
    
    hasForce in interface DynamicAgent
    
    Returns:
    
    true if this component exerts its own forces.
  - getRenderFrame
```
public RigidTransform3d getRenderFrame()
```
    Returns the cached copy of this frame's pose that should be used for rendering. Should not be modified.
    
    Returns:
    
    rendering copy of the pose
  - 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 DynamicAgent
  - zeroForces
```
public void zeroForces()
```
    Specified by:
    
    zeroForces in interface DynamicAgent
  - applyExternalForces
```
public void applyExternalForces()
```
    Specified by:
    
    applyExternalForces in interface DynamicAgent
  - 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: DynamicAgent
    
    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 DynamicAgent
  - isMassConstant
```
public boolean isMassConstant()
```
    Specified by:
    
    isMassConstant in interface DynamicAgent
  - getMass
```
public double getMass(double t)
```
    Description copied from interface: DynamicAgent
    
    Returns the scalar mass of this component at time t.
    
    Specified by:
    
    getMass in interface DynamicAgent
  - getMass
```
public void getMass(Matrix M,
                    double t)
```
    Description copied from interface: DynamicAgent
    
    Gets the mass of this component at a particular time. Not currently used; getEffectiveMass() is used instead.
    
    Specified by:
    
    getMass in interface DynamicAgent
    
    Parameters:
    
    M - matrix to return the mass in
    
    t - current time
  - getEffectiveMass
```
public double getEffectiveMass()
```
    Description copied from interface: DynamicAgent
    
    Gets the effective scalar mass of this component. The effective mass is the nominal mass plus any additional mass incurred from attached components.
    
    Specified by:
    
    getEffectiveMass in interface DynamicAgent
    
    Returns:
    
    effective scalar mass
  - getEffectiveMass
```
public void getEffectiveMass(Matrix M,
                             double t)
```
    Description copied from interface: DynamicAgent
    
    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 DynamicAgent
    
    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 DynamicAgent
  - resetEffectiveMass
```
public void resetEffectiveMass()
```
    Description copied from interface: DynamicAgent
    
    Resets the effective mass of this component to the nominal mass.
    
    Specified by:
    
    resetEffectiveMass in interface DynamicAgent
  - 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)
  - addEffectiveFrameMass
```
public void addEffectiveFrameMass(SpatialInertia M,
                                  RigidTransform3d TFL0)
```
    Adds a frame inertia to the effective spatial inertia for this Frame.
    
    Parameters:
    
    M - spatial inertia to be added
    
    TFL0 - location of the inertia (in local frame coordinates)
  - getEffectiveMassForces
```
public int getEffectiveMassForces(VectorNd f,
                                  double t,
                                  int idx)
```
    Description copied from interface: DynamicAgent
    
    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 DynamicAgent
    
    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 DynamicAgent
    
    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 DynamicAgent
  - setPosState
```
public int setPosState(double[] buf,
                       int idx)
```
    Specified by:
    
    setPosState in interface DynamicAgent
  - addPosImpulse
```
public void addPosImpulse(double[] xbuf,
                          int xidx,
                          double h,
                          double[] vbuf,
                          int vidx)
```
    Specified by:
    
    addPosImpulse in interface DynamicAgent
  - getPosDerivative
```
public int getPosDerivative(double[] dxdt,
                            int idx)
```
    Specified by:
    
    getPosDerivative in interface DynamicAgent
  - getVelState
```
public int getVelState(double[] buf,
                       int idx)
```
    Specified by:
    
    getVelState in interface DynamicAgent
  - 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 DynamicAgent
  - setForce
```
public int setForce(double[] f,
                    int idx)
```
    Specified by:
    
    setForce in interface DynamicAgent
  - addForce
```
public int addForce(double[] f,
                    int idx)
```
    Specified by:
    
    addForce in interface DynamicAgent
  - getForce
```
public int getForce(double[] f,
                    int idx)
```
    Specified by:
    
    getForce in interface DynamicAgent
  - 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
  - getFrameMarkers
```
public FrameMarker[] getFrameMarkers()
```
    Returns an array of all FrameMarkers currently associated with this rigid body.
    
    Returns:
    
    list of all frame markers
  - 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 DynamicAgent
    
    Specified by:
    
    getVelStateSize in interface MotionTargetComponent
  - getPosStateSize
```
public int getPosStateSize()
```
    Specified by:
    
    getPosStateSize in interface DynamicAgent
    
    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 DynamicAgent
    
    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
  - updateAttachmentPosStates
```
public void updateAttachmentPosStates()
```
    Update the state of any dynamic components which are attached to this frame.
  - getState
```
public void getState(DataBuffer data)
```
    Description copied from interface: HasNumericState
    
    Saves state information for this component by adding data to the supplied DataBuffer. Existing data in the buffer should not be disturbed.
    
    Specified by:
    
    getState in interface DynamicAgent
    
    Specified by:
    
    getState in interface HasNumericState
    
    Parameters:
    
    data - buffer for storing the state values.
  - setState
```
public void setState(DataBuffer data)
```
    Description copied from interface: HasNumericState
    
    Restores the state for this component by reading from the supplied data buffer, starting at the current buffer offsets.
    
    Specified by:
    
    setState in interface DynamicAgent
    
    Specified by:
    
    setState in interface HasNumericState
    
    Parameters:
    
    data - buffer containing the state information
  - setRandomPosState
```
public void setRandomPosState()
```
    Sets the position state of this component to a random value. Used for testing.
    
    Specified by:
    
    setRandomPosState in interface DynamicAgent
  - setRandomVelState
```
public void setRandomVelState()
```
    Sets the velocity state of this component to a random value. Used for testing.
    
    Specified by:
    
    setRandomVelState in interface DynamicAgent
  - setRandomForce
```
public void setRandomForce()
```
    Sets the force of this component to a random value. Used for testing.
    
    Specified by:
    
    setRandomForce in interface DynamicAgent
  - add1DConstraintBlocks
```
public void add1DConstraintBlocks(SparseBlockMatrix GT,
                                  int bj,
                                  double scale,
                                  ContactPoint cpnt,
                                  Vector3d dir)
```
    Description copied from interface: ContactMaster
    
    Adds blocks to the constraint matrix GT to implement a 1D constraint in a specified direction. These are used to implement both normal constraints and 1D friction constraints. The block column is specified by bj, while the block row(s) are determined internally by the solve indices of the underlying dynamic components.
    
    Specified by:
    
    add1DConstraintBlocks in interface ContactMaster
    
    Parameters:
    
    GT - constraint matrix
    
    bj - block column index
    
    scale - TODO
    
    cpnt - contact point
    
    dir - friction direction
  - add2DConstraintBlocks
```
public void add2DConstraintBlocks(SparseBlockMatrix GT,
                                  int bj,
                                  double scale,
                                  ContactPoint cpnt,
                                  Vector3d dir0,
                                  Vector3d dir1)
```
    Description copied from interface: ContactMaster
    
    Adds blocks to the constraint matrix GT to implement a 2D constraint in two specified directions. These are used to implement 2D friction constraints in a plane perpendicular to the normal. The block column is specified by bj, while the block row(s) are determined internally by the solve indices of the underlying dynamic components.
    
    Specified by:
    
    add2DConstraintBlocks in interface ContactMaster
    
    Parameters:
    
    GT - constraint matrix
    
    bj - block column index
    
    scale - TODO
    
    cpnt - contact point
    
    dir0 - first friction direction
    
    dir1 - second friction direction
  - addRelativeVelocity
```
public void addRelativeVelocity(Vector3d vel,
                                double scale,
                                ContactPoint cpnt)
```
    Description copied from interface: ContactMaster
    
    Accumulate the velocity at the contact due to the current velocity of the underlying dynamic components.
    
    Specified by:
    
    addRelativeVelocity in interface ContactMaster
    
    Parameters:
    
    vel - accumulates velocity
    
    scale - TODO
    
    cpnt - contact point
  - computeForceOnMasters
```
public void computeForceOnMasters(VectorNd uvec,
                                  Vector3d fc,
                                  double scale,
                                  ContactPoint cpnt,
                                  SparseBlockMatrix S)
```
    Description copied from interface: ContactMaster
    
    XXX Experimental XXX Compute the forces on the masters resulting from a force fc applied at the contact point, and accumulate them in uvec, whose size should equal that of the system forces.
    
    Specified by:
    
    computeForceOnMasters in interface ContactMaster
  - collectMasterComponents
```
public int collectMasterComponents(java.util.HashSet<DynamicComponent> masters,
                                   boolean activeOnly)
```
    Description copied from interface: ContactMaster
    
    Collects all the underlying dynamic ``master'' components. This method returns the number of components that were actually added to masters, i.e., the number of components that were not already present there.
    
    Specified by:
    
    collectMasterComponents in interface ContactMaster
    
    Parameters:
    
    masters - set to which the dynamic components should be added
    
    activeOnly - restrict collected components to those which are active
    
    Returns:
    
    number of components added to masters

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.mechmodels.DynamicAgent

Methods inherited from interface artisynth.core.modelbase.HasNumericState

Methods inherited from interface artisynth.core.modelbase.TransformableGeometry

Methods inherited from interface artisynth.core.mechmodels.ContactMaster

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

getAxisDrawStyle

setAxisDrawStyle

computePointPosition

computePointLocation

computePointVelocity

computePointPosVel

computeFramePosition

computeFrameLocation

computeFrameVelocity

computeFramePosVel

computePointCoriolis

addPointForce

addPointForce

addFrameForce

computeAppliedWrench

resetTargets

getTargetActivity

setTargetActivity

getTargetPosition

setTargetPosition

getTargetOrientation

setTargetOrientation

getTargetPose

setTargetPose

getTargetVelocity