Point (Artisynth API documentation)

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

All Implemented Interfaces:

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

Direct Known Subclasses:

Marker, Particle, PlanarPoint, TargetPoint
```
public class Point
extends DynamicComponentBase
implements TransformableGeometry, ScalableUnits, DynamicComponent, Traceable, MotionTargetComponent, CopyableComponent, CollidableDynamicComponent
```

Field Summary

Fields
Modifier and Type Field and Description

static PropertyList myProps

float[] myRenderCoords
- 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 PropertyList`	`myProps`
`float[]`	`myRenderCoords`

Constructor Summary

Constructors
Constructor and Description

Point()

Point(Point3d pnt)

Point(java.lang.String name, Point3d pnt)

Constructors
Constructor and Description
`Point()`
`Point(Point3d pnt)`
`Point(java.lang.String name, Point3d pnt)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addEffectiveMass(double m)`
`void`	`addExternalForce(Vector3d f)`
`void`	`addForce(Vector3d f)`
`void`	`addLocalForce(Vector3d f)`
`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, Vector3d f)`
`void`	`addScaledForce(double s, Vector3d f)`
`void`	`addScaledLocalForce(double s, Vector3d f)`
`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`	`addToSolveBlockDiagonal(SparseNumberedBlockMatrix S, double d)`
`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.
`ModelComponent`	`copy(int flags, java.util.Map<ModelComponent,ModelComponent> copyMap)` Create a copy of 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).
`RenderProps`	`createRenderProps()` Factory method to create render properties appropriate to this object.
`MatrixBlock`	`createSolveBlock()`
`double`	`distance(Point pnt)`
`double`	`distance(Point3d pos)`
`PropertyList`	`getAllPropertyInfo()` Returns a list giving static information about all properties exported by this object.
`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()`
`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.
`Vector3d`	`getExternalForce()`
`Vector3d`	`getForce()`
`int`	`getForce(double[] f, int idx)`
`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.
`Point3d`	`getLocalPosition()`
`void`	`getLocalPosition(Vector3d pos)`
`Vector3d`	`getLocalVelocity()`
`void`	`getLocalVelocity(Vector3d vel)`
`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.
`double`	`getPointDamping()`
`PropertyMode`	`getPointDampingMode()`
`Frame`	`getPointFrame()`
`int`	`getPosDerivative(double[] dxdt, int idx)`
`Point3d`	`getPosition()` Returns the current position of this point, in world coordinates.
`void`	`getPosition(Point3d pos)`
`int`	`getPosState(double[] x, int idx)`
`int`	`getPosStateSize()`
`float[]`	`getRenderCoords()`
`RenderProps`	`getRenderProps()` Returns the render properities for this object.
`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.
`int`	`getState(VectorNd x, int idx)`
`MotionTarget.TargetActivity`	`getTargetActivity()`
`int`	`getTargetPos(double[] post, double s, double h, int idx)`
`Point3d`	`getTargetPosition()`
`int`	`getTargetVel(double[] velt, double s, double h, int idx)`
`Vector3d`	`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`	`getVelocity()`
`void`	`getVelocity(Vector3d vel)`
`int`	`getVelState(double[] v, int idx)`
`int`	`getVelStateSize()`
`boolean`	`isDuplicatable()` Returns true if this component can be duplicated.
`boolean`	`isMassConstant()`
`boolean`	`isSelectable()` Returns true if this object is in fact selectable.
`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`	`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(Vector3d f)`
`int`	`setForce(double[] f, int idx)`
`void`	`setForce(Vector3d f)`
`void`	`setLocalPosition(double x, double y, double z)`
`void`	`setLocalPosition(Vector3d pos)`
`void`	`setLocalVelocity(double x, double y, double z)`
`void`	`setLocalVelocity(Vector3d vel)`
`void`	`setPointDamping(double d)`
`void`	`setPointDampingMode(PropertyMode mode)`
`void`	`setPointFrame(Frame frame)`
`void`	`setPosition(double x, double y, double z)`
`void`	`setPosition(Point3d p)`
`int`	`setPosState(double[] p, int idx)`
`void`	`setRenderProps(RenderProps props)` Assigns a new set of render properties to this object.
`void`	`setScaledExternalForce(double s, Vector3d f)`
`void`	`setState(Point point)`
`int`	`setState(VectorNd x, int idx)`
`void`	`setTargetActivity(MotionTarget.TargetActivity activity)`
`int`	`setTargetPos(double[] post, int idx)`
`void`	`setTargetPosition(Point3d pos)`
`int`	`setTargetVel(double[] velt, int idx)`
`void`	`setTargetVelocity(Vector3d vel)`
`void`	`setVelocity(double x, double y, double z)`
`void`	`setVelocity(Vector3d vel)`
`int`	`setVelState(double[] v, int idx)`
`void`	`subForce(Vector3d f)`
`void`	`subLocalForce(Vector3d f)`
`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`	`updateBounds(Vector3d pmin, Vector3d pmax)` Update the minimum and maximum points for this object.
`void`	`updatePosState()`
`void`	`updateVelState()`
`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, numSelectionQueriesNeeded, 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
  - myRenderCoords
```
public float[] myRenderCoords
```
  - myProps
```
public static PropertyList myProps
```
- Constructor Detail
  - Point
```
public Point()
```
  - Point
```
public Point(Point3d pnt)
```
  - Point
```
public Point(java.lang.String name,
             Point3d pnt)
```
- 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
  - setPointFrame
```
public void setPointFrame(Frame frame)
```
  - getPointFrame
```
public Frame getPointFrame()
```
  - getForce
```
public Vector3d getForce()
```
  - setForce
```
public void setForce(Vector3d f)
```
  - addForce
```
public void addForce(Vector3d f)
```
  - addScaledForce
```
public void addScaledForce(double s,
                           Vector3d f)
```
  - subForce
```
public void subForce(Vector3d f)
```
  - addLocalForce
```
public void addLocalForce(Vector3d f)
```
  - addScaledLocalForce
```
public void addScaledLocalForce(double s,
                                Vector3d f)
```
  - subLocalForce
```
public void subLocalForce(Vector3d f)
```
  - zeroForces
```
public void zeroForces()
```
    Specified by:
    
    zeroForces in interface DynamicComponent
  - applyExternalForces
```
public void applyExternalForces()
```
    Specified by:
    
    applyExternalForces in interface DynamicComponent
  - addExternalForce
```
public void addExternalForce(Vector3d f)
```
  - addScaledExternalForce
```
public void addScaledExternalForce(double s,
                                   Vector3d f)
```
  - getExternalForce
```
public Vector3d getExternalForce()
```
  - setExternalForce
```
public void setExternalForce(Vector3d f)
```
  - zeroExternalForces
```
public void zeroExternalForces()
```
    Specified by:
    
    zeroExternalForces in interface DynamicComponent
  - setScaledExternalForce
```
public void setScaledExternalForce(double s,
                                   Vector3d f)
```
  - 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
  - getPosition
```
public Point3d getPosition()
```
    Returns the current position of this point, in world coordinates. The returned value should be treated as read-only and not modified.
    
    Returns:
    
    current world position (read-only)
  - getPosition
```
public void getPosition(Point3d pos)
```
  - setPosition
```
public void setPosition(Point3d p)
```
  - setPosition
```
public void setPosition(double x,
                        double y,
                        double z)
```
  - distance
```
public double distance(Point pnt)
```
  - distance
```
public double distance(Point3d pos)
```
  - getPosState
```
public int getPosState(double[] x,
                       int idx)
```
    Specified by:
    
    getPosState in interface DynamicComponent
  - setPosState
```
public int setPosState(double[] p,
                       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
  - getVelocity
```
public Vector3d getVelocity()
```
  - getVelocity
```
public void getVelocity(Vector3d vel)
```
  - setVelocity
```
public void setVelocity(Vector3d vel)
```
  - setVelocity
```
public void setVelocity(double x,
                        double y,
                        double z)
```
  - getVelState
```
public int getVelState(double[] v,
                       int idx)
```
    Specified by:
    
    getVelState in interface DynamicComponent
  - setVelState
```
public int setVelState(double[] v,
                       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
  - 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)
```
  - getTargetVelocity
```
public Vector3d getTargetVelocity()
```
  - setTargetVelocity
```
public void setTargetVelocity(Vector3d 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)
```
    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
  - getPointDamping
```
public double getPointDamping()
```
  - setPointDamping
```
public void setPointDamping(double d)
```
  - getPointDampingMode
```
public PropertyMode getPointDampingMode()
```
  - setPointDampingMode
```
public void setPointDampingMode(PropertyMode mode)
```
  - 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
  - getRenderCoords
```
public float[] getRenderCoords()
```
  - setRenderProps
```
public void setRenderProps(RenderProps props)
```
    Description copied from interface: HasRenderProps
    
    Assigns a new set of render properties to this object. An argument of null will remove render properties from this object.
    
    Specified by:
    
    setRenderProps in interface HasRenderProps
    
    Overrides:
    
    setRenderProps in class RenderableComponentBase
    
    Parameters:
    
    props - new render properties for this object
  - getRenderProps
```
public RenderProps getRenderProps()
```
    Description copied from interface: HasRenderProps
    
    Returns the render properities for this object. If no render properties are assigned, this routines returns null.
    
    Specified by:
    
    getRenderProps in interface HasRenderProps
    
    Overrides:
    
    getRenderProps in class RenderableComponentBase
    
    Returns:
    
    current render properties for this object
  - 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
  - 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.
  - 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
  - isSelectable
```
public boolean isSelectable()
```
    Description copied from class: RenderableComponentBase
    
    Returns true if this object is in fact selectable.
    
    Specified by:
    
    isSelectable in interface IsSelectable
    
    Overrides:
    
    isSelectable in class RenderableComponentBase
    
    Returns:
    
    true if this object is selectable
  - 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
  - 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
  - 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
  - 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
  - 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 double getEffectiveMass()
```
  - 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
  - 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
  - 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
  - addEffectiveMass
```
public void addEffectiveMass(double m)
```
  - addSolveBlock
```
public void addSolveBlock(SparseNumberedBlockMatrix S)
```
    Specified by:
    
    addSolveBlock in interface DynamicComponent
    
    Specified by:
    
    addSolveBlock in class DynamicComponentBase
  - createSolveBlock
```
public MatrixBlock createSolveBlock()
```
  - setState
```
public void setState(Point point)
```
  - setState
```
public int setState(VectorNd x,
                    int idx)
```
  - getState
```
public int getState(VectorNd x,
                    int idx)
```
  - addToSolveBlockDiagonal
```
public void addToSolveBlockDiagonal(SparseNumberedBlockMatrix S,
                                    double d)
```
  - 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()
```
    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)
```
    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
  - copy
```
public ModelComponent 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
  - 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
  - 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
  - getLocalPosition
```
public void getLocalPosition(Vector3d pos)
```
  - getLocalPosition
```
public Point3d getLocalPosition()
```
  - setLocalPosition
```
public void setLocalPosition(Vector3d pos)
```
  - setLocalPosition
```
public void setLocalPosition(double x,
                             double y,
                             double z)
```
  - getLocalVelocity
```
public void getLocalVelocity(Vector3d vel)
```
  - getLocalVelocity
```
public Vector3d getLocalVelocity()
```
  - setLocalVelocity
```
public void setLocalVelocity(Vector3d vel)
```
  - setLocalVelocity
```
public void setLocalVelocity(double x,
                             double y,
                             double z)
```
  - updatePosState
```
public void updatePosState()
```
  - updateVelState
```
public void updateVelState()
```

Class Point

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

myRenderCoords

myProps

Constructor Detail

Point

Point

Point

Method Detail

getAllPropertyInfo

setPointFrame

getPointFrame

getForce

setForce

addForce

addScaledForce

subForce

addLocalForce

addScaledLocalForce

subLocalForce

zeroForces

applyExternalForces

addExternalForce

addScaledExternalForce

getExternalForce

setExternalForce

zeroExternalForces

setScaledExternalForce

applyForces

addVelJacobian

addPosJacobian

addSolveBlocks

getJacobianType

getPosition

getPosition

setPosition

setPosition

distance

distance

getPosState

setPosState

addPosImpulse

getPosDerivative

getVelocity

getVelocity

setVelocity

setVelocity

getVelState

setVelState

setForce

getForce

resetTargets

getTargetActivity

setTargetActivity

getTargetPosition

setTargetPosition

getTargetVelocity

setTargetVelocity

getTargetVel

setTargetVel

getTargetPos

setTargetPos

addTargetJacobian

getPointDamping

setPointDamping

getPointDampingMode

setPointDampingMode