Joint

java.lang.Object
- msim.model.LinkageNode
- - msim.model.Joint

All Implemented Interfaces:

java.lang.Comparable<LinkageNode>

Direct Known Subclasses:

RootJoint
```
@ThreadSafe
public class Joint
extends LinkageNode
```
Structured rigid transform from one Link to another.

TBD
- refactor updateWidgetsImpl()
See additional description in header doc for Linkage.

Copyright (C) 2008 Marsette A. Vona, III
Author:

Marsette A. Vona, III

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Joint.ResidualType` Residual type requested for `getResidual(int, ResidualType, int, double[])`.
`protected static class`	`Joint.SliderSegmentWidget` A specialization that knows how to track start and end coords as described in `addSegmentWidget(int, float)`.
`static class`	`Joint.Type` The set of available types of Joint.

Nested classes/interfaces inherited from class msim.model.LinkageNode
LinkageNode.ApplyingNodeHandler, LinkageNode.NodeHandler, LinkageNode.SubFrame

Field Summary

Fields
Modifier and Type	Field and Description
`static int[]`	`ALL_TXEM_INDICES` vector of all six TXEM indices
`static float`	`AXES_RADIUS_FACTOR` Joint `AxesWidget` radius relative to `LinkageNode.widgetLength`
`Link`	`branchLink` For a chain closure joint, `Controller.analyze()` sets this to the least common ancestor of the model tree branches containing `parentLink` and `childLink`.
`static double`	`BROKEN_TOL` tolerance for `isBroken()`
`protected Link`	`childLink` The immediate descendant of this joint, or null if dangling.
`protected java.util.List<Link>`	`childLinks` Contains `childLink` (for `getChildren()`), empty if dangling.
`protected vona.math.RX`	`childMobilityCMT` cached quantity
`protected boolean`	`childMobilityCMTDirty` dirty flag for indicated quantity
`protected double[]`	`childMobilityCMTQuaternion` cached quantity
`protected boolean`	`childMobilityCMTQuaternionDirty` dirty flag for indicated quantity
`protected double[]`	`childMobilityCMTRotMatrix` cached quantity
`protected boolean`	`childMobilityCMTRotMatrixDirty` dirty flag for indicated quantity
`protected java.lang.String`	`childSubFrame` Subframe in child link corresponding to `childToMobilityRX`, if any.
`protected vona.math.RX`	`childToMobilityRX` Sub transform taking the child frame to the child mobility frame.
`static vona.color.ColorScheme`	`CLOSURE_ROUTE_COLOR_SCHEME` Color scheme for closure joint `RouteWidget`s.
`static float`	`CONE_HEIGHT_FACTOR` Joint `ConeWidget` dimensions relative to `LinkageNode.widgetLength`.
`static float`	`CONE_RADIUS_FACTOR` Joint `ConeWidget` dimensions relative to `LinkageNode.widgetLength`.
`private static java.lang.String`	`cvsid`
`static float`	`CYLINDER_HEIGHT_FACTOR` Joint cylinder `Widget` height relative to `LinkageNode.widgetLength`
`static float`	`DEGENERATE_ROUTE_TANGENT_FACTOR` `RouteWidget` endpoint tangent lengths relative to `LinkageNode.widgetLength`.
`static double`	`DEGENERATE_ROUTE_TOL` tolerance for checking route widget degeneracy
`static java.lang.String`	`FMT` decimal printf format
`static java.lang.String`	`FMT_S` string printf format same width as `FMT`
`static int`	`FMT_WIDTH` field width for `FMT`
`static java.lang.String`	`FMT3` multiple `FMT`s
`static java.lang.String`	`FMT3_S` multiple `FMT_S`s
`static java.lang.String`	`FMT4` multiple `FMT`s
`static java.lang.String`	`FMT4_S` multiple `FMT_S`s
`static java.lang.String`	`FMT6` multiple `FMT`s
`static java.lang.String`	`FMT6_S` multiple `FMT_S`s
`static int`	`G_LIMIT` Non-transform goal identifiers.
`protected vona.math.RX`	`invariantRX` Current `mobilityRX` invariant goal.
`int`	`jacobianDoFStartRow` Start indices of the spans of Jacobian rows corresponding to this Joint in `solver`, or -1 if none.
`int`	`jacobianDoIStartRow` Start indices of the spans of Jacobian rows corresponding to this Joint in `solver`, or -1 if none.
`int`	`jacobianLimitStartRow` Start indices of the spans of Jacobian rows corresponding to this Joint in `solver`, or -1 if none.
`int`	`jacobianStartColumn` Start index of the span of Jacobian columns corresponding to this Joint in `solver`, or -1 if none.
`static java.lang.String[]`	`JOINT_SUBFRAMES` all joint subframes
`protected vona.math.RX`	`jointRX` Total transform taking the child frame to the parent frame.
`static java.lang.String`	`JW_AXES` `WP_JOINT` values
`static vona.color.ColorScheme`	`JW_COLOR_SCHEME` Color scheme for Joint `Widget`s.
`static java.lang.String`	`JW_LABEL` `WP_JOINT` values
`static java.lang.String`	`JW_MOBILITY_SLIDER` `WP_JOINT` values
`static java.lang.String`	`JW_MOBILITY_SURFACE` `WP_JOINT` values
`static java.lang.String`	`JW_ROUTE` `WP_JOINT` values
`static java.lang.String`	`JW_ROUTE_CONE` `WP_JOINT` values
`static java.lang.String`	`JW_SLIDER_SURFACE` `WP_JOINT` values
`int`	`lastSupportIndexBeforeBranch` For a chain closure joint, `Controller.analyze()` sets this to the index of the last actuator in `support` before `branchLink`.
`protected double[][]`	`limit` `LOWER` and `UPPER` limits for each DoF iff `limitSet`, NaN for DoF with unset limits, or the invariant value for DoI.
`static int`	`LIMIT_PENALTY_DEGREE` Polynomial degree of the limit penalty function.
`static int`	`LIMITED_EDGE_PATTERN` edge pattern for indicating limited or unlimited mobility
`static float`	`LIMITED_EDGE_WIDTH` edge width for indicating limited or unlimited mobility
`protected boolean[]`	`limitSet` Whether we currently have a `limit` for each TXEM parameter.
`protected boolean`	`locked` whether this Joint is currently locked
`protected vona.math.RX`	`lockRX` Current `mobilityRX` lock goal.
`static int`	`LOWER` `limit` and `limitSet` categories
`static java.awt.Color`	`MOBILITY_ERROR_ROUTE_COLOR` color of mobility routes for broken closures
`protected double[][]`	`mobilitydEMdQ` cached quantity
`protected boolean`	`mobilitydEMdQDirty` dirty flag for indicated quantity
`protected double[][]`	`mobilitydQdEM` cached quantity
`protected boolean`	`mobilitydQdEMDirty` dirty flag for indicated quantity
`protected double[][]`	`mobilitydRdEM` cached quantity
`protected boolean`	`mobilitydRdEMDirty` dirty flag for indicated quantity
`protected double[][]`	`mobilitydRdQ` cached quantity
`protected boolean`	`mobilitydRdQDirty` dirty flag for indicated quantity
`protected boolean`	`mobilityInverted` whether this Joint's mobility space is currently inverted
`protected double[]`	`mobilityQuaternion` cached quantity
`protected boolean`	`mobilityQuaternionDirty` dirty flag for indicated quantity
`protected double[]`	`mobilityRotMatrix` cached quantity
`protected boolean`	`mobilityRotMatrixDirty` dirty flag for indicated quantity
`protected vona.math.RX`	`mobilityRX` Sub transform taking the child mobility frame to the parent mobility frame, or vice-versa if `mobilityInverted`.
`protected vona.math.RX`	`mobilityRXClamped` Mirror of `mobilityRX`, but always clamped to `limit`s.
`protected vona.math.RX`	`mobilityRXClampedInverse` cached quantity
`protected boolean`	`mobilityRXClampedInverseDirty` dirty flag for indicated quantity
`protected vona.math.RX`	`mobilityRXInverse` cached quantity
`protected boolean`	`mobilityRXInverseDirty` dirty flag for indicated quantity
`protected vona.math.RX`	`mobilityToParentRX` Sub transform taking the parent mobility frame to the parent frame.
`static int`	`NUM_CHAIN_SUBTRANSFORMS` number of subtransforms
`static int`	`NUM_CONE_SECTORS` number of sectors for `ConeWidget`s
`static int`	`NUM_GOAL_SUBTRANSFORMS` number of subtransforms
`static int`	`NUM_HARD_GOAL_SUBTRANSFORMS` number of subtransforms
`static int`	`NUM_RESIDUAL_TYPES` number of different `Joint.ResidualType`s
`static int`	`NUM_ROUTE_SEGMENTS` number of segments for `RouteWidget`s
`static int`	`NUM_SOFT_GOAL_SUBTRANSFORMS` number of subtransforms
`static int`	`NUM_SUBTRANSFORMS` number of subtransforms
`static int`	`NUM_TYPES` number of different `Joint.Type`s
`protected Link`	`parentLink` The `Link` leading to this joint, or null if dangling.
`protected vona.math.RX`	`parentMobilityCMT` cached quantity
`protected boolean`	`parentMobilityCMTDirty` dirty flag for indicated quantity
`protected double[]`	`parentMobilityCMTQuaternion` cached quantity
`protected boolean`	`parentMobilityCMTQuaternionDirty` dirty flag for indicated quantity
`protected double[]`	`parentMobilityCMTRotMatrix` cached quantity
`protected boolean`	`parentMobilityCMTRotMatrixDirty` dirty flag for indicated quantity
`protected java.lang.String`	`parentSubFrame` Subframe in parent link corresponding to `mobilityToParentRX`, if any.
`static int`	`PG_GRAVITY` Non-transform goal identifiers.
`static int`	`PG_POTENTIAL` Non-transform goal identifiers.
`static int`	`PG_STIFFNESS` Non-transform goal identifiers.
`static float`	`PLANAR_RECTANGLE_ALPHA` Joint revolute/cylindrical/pin-slider sector, pin-slider/point-slider prism, and planar/point-plane rectangle `Widget` face alphas.
`protected boolean`	`positioningTransformsLocked` Whether `RX_CHILD_TO_MOBILITY` and `RX_MOBILITY_TO_PARENT` are currently locked.
`protected vona.math.RX`	`postureRX` Current `mobilityRX` posture.
`protected boolean`	`potentialEnabled` Gating enable for any potential goal.
`static Joint.ResidualType[]`	`RESIDUAL_TYPES` set of all `Joint.ResidualType`s, do not modify
`static float`	`REVOLUTE_SECTOR_ALPHA` Joint revolute/cylindrical/pin-slider sector, pin-slider/point-slider prism, and planar/point-plane rectangle `Widget` face alphas.
`protected boolean`	`rotationDoFLimited` Whether the indicated motion DoF space has any limits currently set.
`static float`	`ROUTE_LINE_WIDTH` line width for `RouteWidget`s
`static float`	`ROUTE_TANGENT_FACTOR` `RouteWidget` endpoint tangent lengths relative to `LinkageNode.widgetLength`.
`static int`	`RX_CHILD_TO_MOBILITY` Sub-transform identifiers, goals must come first to support indexing in `setGoalComponents`.
`static int`	`RX_INVARIANT` Sub-transform identifiers, goals must come first to support indexing in `setGoalComponents`.
`static int`	`RX_LOCK` Sub-transform identifiers, goals must come first to support indexing in `setGoalComponents`.
`static int`	`RX_MOBILITY` Sub-transform identifiers, goals must come first to support indexing in `setGoalComponents`.
`static int`	`RX_MOBILITY_TO_PARENT` Sub-transform identifiers, goals must come first to support indexing in `setGoalComponents`.
`static int`	`RX_POSTURE` Sub-transform identifiers, goals must come first to support indexing in `setGoalComponents`.
`static int`	`RX_TARGET` Sub-transform identifiers, goals must come first to support indexing in `setGoalComponents`.
`static float`	`SECTOR_MARGIN` Joint extendable `SectorWidget` margin in radians.
`static float`	`SECTOR_OFFSET_FACTOR` Joint segment and sector `Widget` lengths relative to `LinkageNode.widgetLength`.
`static float`	`SECTOR_WIDTH_FACTOR` Joint segment and sector `Widget` lengths relative to `LinkageNode.widgetLength`.
`static float`	`SEGMENT_LENGTH_FACTOR` Joint segment and sector `Widget` lengths relative to `LinkageNode.widgetLength`.
`static float`	`SEGMENT_OFFSET_FACTOR` Joint segment and sector `Widget` lengths relative to `LinkageNode.widgetLength`.
`protected int[][]`	`setGoalComponents` cached quantity
`protected int[]`	`setLimitComponents` cached quantity: limited DoF indices only (no DoI)
`protected int[][]`	`setRotationGoalComponents` cached quantity
`protected int[]`	`setRotationLimitComponents` cached quantity: limited DoF indices only (no DoI)
`protected int[][]`	`setTranslationGoalComponents` cached quantity
`protected int[]`	`setTranslationLimitComponents` cached quantity: limited DoF indices only (no DoI)
`static java.lang.String`	`SF_CHILD` Subframes.
`static java.lang.String`	`SF_CHILD_MOBILITY` Subframes.
`static java.lang.String`	`SF_MOBILITY_FROM` Subframes.
`static java.lang.String`	`SF_MOBILITY_TO` Subframes.
`static java.lang.String`	`SF_PARENT` Subframes.
`static java.lang.String`	`SF_PARENT_MOBILITY` Subframes.
`protected double`	`singleMobilityDoF` cached quantity
`protected boolean`	`singleMobilityDoFDirty` dirty flag for indicated quantity
`static float`	`SLIDER_EDGE_WIDTH` slider widget edge width
`static float`	`SLIDER_PRISM_ALPHA` Joint revolute/cylindrical/pin-slider sector, pin-slider/point-slider prism, and planar/point-plane rectangle `Widget` face alphas.
`float`	`softGoalPriority` Solve priority of the highest priority soft goal of this Joint in `solver`.
`int`	`softGoalSolveLevel` Solve level of the highest priority soft goal, if any, of this Joint in `solver`.
`double`	`softGoalWeight` Solve weight of the highest priority soft goal of this Joint in `solver`.
`Solver`	`solver` the `Solver` assigned by `Controller.analyze()`, iff any
`protected double`	`stiffness` stiffness of this joint or NaN if unset
`protected double`	`stiffnessRest` stiffness rest pose of this joint, default 0
`static java.lang.String[]`	`SUB_RX_NAME` names of the sub-transforms
`protected vona.math.RX[]`	`subRX` the various sub-transforms, indexed by identifier
`java.util.List<Joint>`	`support` Joints associated to this Joint in a `Solver`.
`protected vona.math.RX`	`targetRX` Current `mobilityRX` target.
`protected vona.math.RX`	`tempRX` a temp transform
`protected float[][]`	`tempV3` temp storage
`protected double[]`	`tempV3D` temp storage
`protected boolean`	`translationDoFLimited` Whether the indicated motion DoF space has any limits currently set.
`static vona.color.ColorScheme`	`TREE_ROUTE_COLOR_SCHEME` Color scheme for tree joint `RouteWidget`s.
`protected Joint.Type`	`type` the current Joint `Joint.Type`
`static Joint.Type[]`	`TYPES` set of all `Joint.Type`s, do not modify
`static int`	`UNLIMITED_EDGE_PATTERN` edge pattern for indicating limited or unlimited mobility
`static float`	`UNLIMITED_EDGE_WIDTH` edge width for indicating limited or unlimited mobility
`protected java.util.List<Link>`	`unmodifiableChildLinks` unmodifiable view of `childLinks`
`protected int[][]`	`unsetGoalComponents` cached quantity
`protected int[]`	`unsetLimitComponents` cached quantity: unlimited DoF indices only (no DoI)
`static int`	`UPPER` `limit` and `limitSet` categories
`static float`	`WIDGET_MARGIN` Joint extendable `Widget` margin relative to `LinkageNode.widgetLength`.
`static int`	`WIDGET_NUM_SECTORS` Joint cylinder, sphere, and circle `Widget` sector counts
`static float`	`WIDGET_RADIUS_FACTOR` Joint cylinder, sphere, and circle `Widget` radii relative to `LinkageNode.widgetLength`.
`static float`	`WIDGET_WIDTH_FACTOR` Joint prism and square `Widget` widths relative to `LinkageNode.widgetLength`.
`static java.lang.String`	`WN_C_TO_M_ROUTE` Joint `Widget` names
`static java.lang.String`	`WN_CHILD_MOBILITY_AXES` Joint `Widget` names
`static java.lang.String`	`WN_JOINT_CIRCLE` Joint `Widget` names
`static java.lang.String`	`WN_JOINT_CYLINDER` Joint `Widget` names
`static java.lang.String`	`WN_JOINT_LABEL` Joint `Widget` names
`static java.lang.String`	`WN_JOINT_PRISM` Joint `Widget` names
`static java.lang.String`	`WN_JOINT_PRISM_ENDS` Joint `Widget` names
`static java.lang.String`	`WN_JOINT_RECTANGLE` Joint `Widget` names
`static java.lang.String`	`WN_JOINT_RECTANGLE_Y_EDGES` Joint `Widget` names
`static java.lang.String`	`WN_JOINT_SECTOR` Joint `Widget` names
`static java.lang.String`	`WN_JOINT_SECTOR_ENDS` Joint `Widget` names
`static java.lang.String`	`WN_JOINT_SEGMENT` Joint `Widget` names
`static java.lang.String`	`WN_JOINT_SPHERE` Joint `Widget` names
`static java.lang.String`	`WN_JOINT_SQUARE` Joint `Widget` names
`static java.lang.String`	`WN_M_TO_P_ROUTE` Joint `Widget` names
`static java.lang.String`	`WN_MOBILITY_ROUTE` Joint `Widget` names
`static java.lang.String`	`WN_PARENT_MOBILITY_AXES` Joint `Widget` names
`static java.lang.String`	`WN_ROUTE_CONE_SUFFIX` Joint `Widget` names
`static java.lang.String`	`WP_JOINT` `Widget` property identifying a Joint widget
`static java.lang.String`	`WP_ROUTE` `Widget` property identifying the `RouteWidget` to which this widget is associated.

Fields inherited from class msim.model.LinkageNode
autoNamed, cmt, DEF_WIDGET_LENGTH, depth, entityClass, explicitlyHidden, explicitlyHighlighted, explicitlyMasked, explicitlyVisible, linkage, name, nextAnonymousWidgetNumber, nodeWidgets, numUserWidgets, propertyMap, SF_CANONICAL, TM_JOINT_TYPE_START, TM_NUM_CLOSURE_JOINTS, TM_NUM_CONSTRAINED_CLOSURE_JOINTS, TM_NUM_DANGLING_JOINTS, TM_NUM_JOINT_WIDGETS, TM_NUM_JOINTS, TM_NUM_LINK_WIDGETS, TM_NUM_LINKAGES, TM_NUM_LINKS, TM_NUM_LOCKED_LINKS, TM_NUM_NODES, TM_NUM_SUPPORTING_TREE_JOINTS, TM_NUM_TREE_JOINTS, TM_NUM_UNCONSTRAINED_CLOSURE_JOINTS, TM_NUM_UNLOCKED_TREE_JOINTS, TM_NUM_WIDGETS, TM_SIZE, unmodifiableWidgets, widgetLength, widgetMap, widgets, widgetsDirty, WP_CACHED_SUBFRAME, WP_EXPLICIT_HIDDEN, WP_EXPLICIT_HIGHLIGHT, WP_EXPLICIT_MASK, WP_EXPLICIT_VISIBLE, WP_FRAME, WP_NAME, WP_NODE, WP_USER_SUBFRAME

Constructor Summary

Constructors
Constructor and Description
`Joint(Linkage linkage)` Covers `Joint(Linkage, String, Type, Link, Link)`, initially disconnected, `Joint.Type.GENERAL`, and auto-named.
`Joint(Linkage linkage, Joint.Type type)` Covers `Joint(Linkage, String, Type, Link, Link)`, initially disconnected, auto-named.
`Joint(Linkage linkage, Joint.Type type, LinkageNode.SubFrame parent, LinkageNode.SubFrame child)` Covers `Joint(Linkage, Type, Link, String, Link, String)`.
`Joint(Linkage linkage, Joint.Type type, Link parentLink, Link childLink)` Covers `Joint(Linkage, String, Type, Link, Link)`, auto-named.
`Joint(Linkage linkage, Joint.Type type, Link parentLink, java.lang.String parentSubFrame, Link childLink, java.lang.String childSubFrame)` Covers `Joint(Linkage, String, Type, Link, String, Link, String)`, auto-named.
`Joint(Linkage linkage, LinkageNode.SubFrame parent, LinkageNode.SubFrame child)` Covers `Joint(Linkage, Link, String, Link, String)`.
`Joint(Linkage linkage, Link parentLink, Link childLink)` Covers `Joint(Linkage, String, Type, Link, Link)`, initially `Joint.Type.GENERAL` and auto named.
`Joint(Linkage linkage, Link parentLink, java.lang.String parentSubFrame, Link childLink, java.lang.String childSubFrame)` Covers `Joint(Linkage, String, Type, Link, String, Link, String)`, initially `Joint.Type.GENERAL` and auto named.
`Joint(Linkage linkage, java.lang.String name)` Covers `Joint(Linkage, String, Type, Link, Link)`, initially disconnected and `Joint.Type.GENERAL`.
`Joint(Linkage linkage, java.lang.String name, Joint.Type type)` Covers `Joint(Linkage, String, Type, Link, Link)`, initially disconnected.
`Joint(Linkage linkage, java.lang.String name, Joint.Type type, LinkageNode.SubFrame parent, LinkageNode.SubFrame child)` Covers `Joint(Linkage, String, Type, Link, String, Link, String)`.
`Joint(Linkage linkage, java.lang.String name, Joint.Type type, Link parentLink, Link childLink)` Covers `Joint(Linkage, String, Type, Link, String, Link, String)`, does not attach to subframes.
`Joint(Linkage linkage, java.lang.String name, Joint.Type type, Link parentLink, java.lang.String parentSubFrame, Link childLink, java.lang.String childSubFrame)` Makes a new chain closure joint and adds it to linkage.
`Joint(Linkage linkage, java.lang.String name, LinkageNode.SubFrame parent, LinkageNode.SubFrame child)` Covers `Joint(Linkage, String, Link, String, Link, String)`.
`Joint(Linkage linkage, java.lang.String name, Link parentLink, Link childLink)` Covers `Joint(Linkage, String, Type, Link, Link)`, initially `Joint.Type.GENERAL`.
`Joint(Linkage linkage, java.lang.String name, Link parentLink, java.lang.String parentSubFrame, Link childLink, java.lang.String childSubFrame)` Covers `Joint(Linkage, String, Type, Link, String, Link, String)`, initially `Joint.Type.GENERAL`.

Method Summary

Methods
Modifier and Type	Method and Description
`protected vona.j3d.AxesWidget`	`addAxesWidget(java.lang.String name, java.lang.String frame)` Adds an `AxesWidget` with `AXES_RADIUS_FACTOR` radius in indicated frame.
`protected vona.j3d.CircleWidget`	`addCircleWidget()` Adds a `CircleWidget` with `WIDGET_RADIUS_FACTOR` radius in the XY plane, symmetric about the Z axis in `SF_MOBILITY_FROM`.
`protected vona.j3d.CylinderWidget`	`addCylinderWidget()` Adds a `CylinderWidget` with `WIDGET_RADIUS_FACTOR` radius symmetric about a line parallel to the parent mobility z axis but through the origin of `SF_MOBILITY_FROM`.
`protected vona.j3d.PrismWidget`	`addPrismWidgets(int axis, float alpha, float extraMargin)` Adds a `PrismWidget` with a square `WIDGET_WIDTH_FACTOR` profile symmetric about axis in `SF_MOBILITY_TO`.
`protected vona.j3d.RectangleWidget`	`addRectangleWidgets(float extraMargin)` Adds a `RectangleWidget` in the XY plane in `SF_MOBILITY_TO`.
`protected vona.j3d.RouteWidget`	`addRouteWidgets(java.lang.String name, java.lang.String frame, int rx)` Adds route widgets for the indicated sub-transform.
`protected vona.j3d.SectorWidget`	`addSectorWidgets(float alpha)` Adds a `SectorWidget` in the XY plane of `SF_MOBILITY_TO` centered on a line parallel to the Z axis but through the origin of `SF_MOBILITY_FROM`, with inner radius `SECTOR_OFFSET_FACTOR` and width `SECTOR_WIDTH_FACTOR`.
`protected vona.j3d.SegmentWidget`	`addSegmentWidget(int axis, float offsetFactor)` Adds a `Joint.SliderSegmentWidget` on the indicated axis of `SF_MOBILITY_FROM`, starting at offsetFactor and ending at (offsetFactor+`SEGMENT_LENGTH_FACTOR`).
`protected vona.j3d.SphereWidget`	`addSphereWidget()` Adds a `SphereWidget` with `WIDGET_RADIUS_FACTOR` radius at the origin in `SF_MOBILITY_FROM`.
`protected vona.j3d.RectangleWidget`	`addSquareWidget()` Adds a `RectangleWidget` with `WIDGET_WIDTH_FACTOR` width and height in the XY plane, axis aligned, symmetric about the Z axis in `SF_MOBILITY_FROM`.
`boolean`	`checkName(java.lang.String name)` Extends superclass impl to verify name is unique in `parentLink`, if any.
`java.lang.String`	`checkType(Joint.Type type)` Check if type is a valid type for this joint in its current connected configuration.
`double`	`clampDoFToLimits(int index, double value)` Clamp DoF component value to the current `limit`s for the DoF at index.
`boolean`	`clampToLimits(vona.math.RX rx)` Clamp rx to the current mobility space `limit`s.
`Link`	`detachChildLink()` `setChildLink(Link)` null
`Link`	`detachParentLink()` `setParentLink(Link)` null
`boolean`	`disablePotential()` covers `setPotentialEnabled(boolean)`
`void`	`dump(java.io.PrintStream s)` dump Joint details
`void`	`dumpSolverInfo()` `dumpSolverInfo(PrintStream)` to System.out
`void`	`dumpSolverInfo(java.io.PrintStream s)` Describing the role of this Joint in its `solver`, if any.
`void`	`dumpState()` `dumpState(PrintStream)` to System.out
`void`	`dumpState(java.io.PrintStream s)` dump mobility and related numeric state
`void`	`dumpSubFrames(java.io.PrintStream s)` Dump all available subframes.
`void`	`dumpSubJacobian(Joint other)` `dumpSubJacobian(Joint, PrintStream)` to System.out
`void`	`dumpSubJacobian(Joint other, java.io.PrintStream s)` `Solver.dumpSubJacobian(Joint, Joint, PrintStream)` that relates this Joint, whether it's an actuator or an effector, to other in `solver`, if any.
`void`	`dumpSubRXState(int which)` `dumpSubRXState(PrintStream, int)` to System.out
`void`	`dumpSubRXState(java.io.PrintStream s, int which)` one-line dump of the state of one of the sub-transforms
`void`	`dumpSupport()` `dumpSupport(PrintStream)` to System.out
`void`	`dumpSupport(java.io.PrintStream s)` dump the `support` of this Joint
`protected void`	`dumpTree(java.lang.String prefix, java.io.PrintStream s)` impl of `LinkageNode.dumpTree(PrintStream)`
`boolean`	`enablePotential()` covers `setPotentialEnabled(boolean)`
`double[]`	`getAllDoFLimits()` Get the upper and lower limits for all DoF.
`double[]`	`getAllRotationLimits()` similar to `getAllTranslationLimits()`
`double[]`	`getAllTranslationLimits()` Get the upper and lower limits for all translation DoF.
`static java.lang.String`	`getAttachmentName(Link link, java.lang.String subFrame)` common impl of `getParentName()` and `getChildName()`
`Link`	`getBranchLink()` get the `branchLink` of this Joint, if any
`LinkageNode`	`getChild(java.lang.String name)` returns `childLink` iff name matches
`Link`	`getChildLink()` get the current `childLink`, null if none
`double[]`	`getChildMobilityCMTQuaternionRef()` get a ref to the indicated cached quantity, recomputing if dirty
`vona.math.RX`	`getChildMobilityCMTRef()` get a ref to the indicated cached quantity, recomputing if dirty
`double[]`	`getChildMobilityCMTRotMatrixRef()` get a ref to the indicated cached quantity, recomputing if dirty
`java.lang.String`	`getChildName()` Get the name of the current attached child and child subframe, if any, else null.
`java.util.Collection<? extends LinkageNode>`	`getChildren()` returns an unmodifiable view of `childLinks`
`java.lang.String`	`getChildSubFrame()` get the current `childSubFrame`, null if none
`vona.math.RX`	`getChildTOMobility(vona.math.RX rx)` covers `getSubRX(int, RX)`, gets `RX_CHILD_TO_MOBILITY`
`vona.math.RX`	`getChildToMobilityRX()` Covers `getSubRX(int, RX)`, gets `RX_CHILD_TO_MOBILITY` and conses.
`double[]`	`getDoF()` `getDoF(int, int[], int, double[], boolean)` getting `RX_MOBILITY` with EM ailias in limits.
`double[]`	`getDoF(int which)` `getDoF(int, int[], int, double[], boolean)` with EM ailias in limits.
`double[]`	`getDoF(int which, double[] dof)` `getDoF(int, int[], int, double[], boolean)` with EM ailias in limits.
`double[]`	`getDoF(int which, int[] dofIndex, double[] dof)` `getDoF(int, int[], int, double[], boolean)` with EM ailias in limits.
`double[]`	`getDoF(int which, int[] dofIndex, int start, double[] dof, boolean getEMAliasInLimits)` Retrieve the current Degree of Freedom values of the packed translation and exponential map vector corresponding to a goal or to the mobility sub-transform.
`double[]`	`getDoF(int which, int start, double[] dof)` `getDoF(int, int[], int, double[], boolean)` with EM ailias in limits.
`int[]`	`getDoFIndices()` `getDoFIndices(int, int[])` starting at 0 and consing
`int[]`	`getDoFIndices(int[] indices)` `getDoFIndices(int, int[])` starting at 0
`int[]`	`getDoFIndices(int start, int[] indices)` get the TXEM vector indices of the DoF in the current `type`
`int[]`	`getDoFIndicesRef()` Get a reference to the TXEM vector indices of the DoF in the current `type`.
`double[]`	`getDoFLimits(int which)` Covers `getDoFLimits(int, int, double[])`, starts at 0, always conses.
`double[]`	`getDoFLimits(int which, double[] values)` Covers `getDoFLimits(int, int, double[])`, starts at 0.
`double[]`	`getDoFLimits(int which, int start, double[] values)` Get the `LOWER` or `UPPER` limits of the Degrees of Freedom, if set.
`java.lang.String[]`	`getDoFNames()` `getDoFNames(int, String[])` starting at 0 and consing
`java.lang.String[]`	`getDoFNames(int start, java.lang.String[] names)` like `getDoFIndices(int, int[])` but gets TXEM component names
`java.lang.String[]`	`getDoFNames(java.lang.String[] names)` `getDoFNames(int, String[])` starting at 0
`int[]`	`getDoIIndices()` `getDoIIndices(int, int[])` starting at 0 and consing
`int[]`	`getDoIIndices(int[] indices)` `getDoIIndices(int, int[])` starting at 0
`int[]`	`getDoIIndices(int start, int[] indices)` similar to `getDoFIndices(int, int[])` but gets Degrees of Invariance
`int[]`	`getDoIIndicesRef()` similar to `getDoFIndicesRef()` but gets Degrees of Invariance
`java.lang.String[]`	`getDoINames()` `getDoINames(int, String[])` starting at 0 and consing
`java.lang.String[]`	`getDoINames(int start, java.lang.String[] names)` like `getDoIIndices(int, int[])` but gets TXEM component names
`java.lang.String[]`	`getDoINames(java.lang.String[] names)` `getDoINames(int, String[])` starting at 0
`static java.lang.String`	`getGoalName(int which)` get the human readable name for the indicated goal
`boolean[]`	`getGoalStatus(int which, boolean[] status)` `getGoalStatus(int, int, boolean[])`, starting at 0
`boolean[]`	`getGoalStatus(int which, int start, boolean[] status)` like `getGoalStatus(int, int, String[])`
`java.lang.String[]`	`getGoalStatus(int which, int start, java.lang.String[] status)` Get the status, "set" or "unset" of each goal component.
`java.lang.String[]`	`getGoalStatus(int which, java.lang.String[] status)` `getGoalStatus(int, int, String[])`, starting at 0
`boolean[]`	`getGoalStatusBoolean(int which)` `getGoalStatus(int, int, boolean[])`, starting at 0 and consing
`java.lang.String[]`	`getGoalStatusString(int which)` `getGoalStatus(int, int, String[])`, starting at 0 and consing
`double`	`getGravityPotential()` Get the current potential energy stored by this joint due to gravity.
`double`	`getGravityPotential(vona.math.RX mobilityRX)` Impl of `getGravityPotential()`.
`int`	`getHighestPrioritySoftGoal()` Get the id of the highest-priority "soft" goal that is currently set.
`protected int[]`	`getIndices(int[] source, int writeStart, int[] dest)` Helper method to copy source to dest, consing if necessary.
`double`	`getInvariant(int index)` Get the invariant value of a TXEM component, NaN if not an invariant.
`double[]`	`getInvariants()` Covers `getInvariants(int, double[])`, starts at 0 and conses.
`double[]`	`getInvariants(double[] values)` Covers `getInvariants(int, double[])`, starts at 0.
`double[]`	`getInvariants(int start, double[] values)` Get the values of the Degrees of Invariance of the current Joint `type`.
`int`	`getJacobianDoFStartRow()` Get this Joint's `jacobianDoFStartRow` in its `solver`, if any, else negative.
`int`	`getJacobianDoIStartRow()` Get this Joint's `jacobianDoIStartRow` in its `solver`, if any, else negative.
`int`	`getJacobianLimitStartRow()` Get this Joint's `jacobianLimitStartRow` in its `solver`, if any, else negative.
`int`	`getJacobianStartColumn()` Get this Joint's `jacobianStartColumn` in its `solver`, if any, else negative.
`vona.math.RX`	`getJointRX()` covers `getJointRX(RX)`, always conses
`vona.math.RX`	`getJointRX(vona.math.RX rx)` get a copy of `jointRX`, consing if null
`vona.math.RX`	`getJointRXRef()` get a ref to `jointRX`, do not mutate
`double`	`getLimit(int component, int offset, int which)` Common impl of `getTranslationLimit(int, int)` and `getRotationLimit(int, int)`.
`double[]`	`getLimitExcess()` Covers `getLimitExcess(RX, int[], int, double[])`, uses `setLimitComponents` and `mobilityRX`, starts writing at index 0 and conses.
`double[]`	`getLimitExcess(double[] excess)` Covers `getLimitExcess(RX, int[], int, double[])`, uses `setLimitComponents` and `mobilityRX`, starts writing at index 0.
`double`	`getLimitExcess(int index)` Get the signed amount by which a particular DoF exceeds its current limits, if any.
`double[]`	`getLimitExcess(int start, double[] excess)` Covers `getLimitExcess(RX, int[], int, double[])`, uses `setLimitComponents` and `mobilityRX`.
`double[]`	`getLimitExcess(vona.math.RX mobilityRX, int[] indices, int start, double[] excess)` Generalizes `getLimitExcess(int)` to get a vector of excesses.
`double[]`	`getLimitExcess(vona.math.RX mobilityRX, int start, double[] excess)` Covers `getLimitExcess(RX, int[], int, double[])`, uses `setLimitComponents`.
`static java.lang.String`	`getLimitGoalName()` get the human readable name for the limit goal
`double[]`	`getLimitPenalty()` Covers `getLimitPenalty(RX, int[], int, double[])`, uses `setLimitComponents` and `mobilityRX`, starts writing at index 0 and conses.
`double[]`	`getLimitPenalty(double[] penalty)` Covers `getLimitPenalty(RX, int[], int, double[])`, uses `setLimitComponents` and `mobilityRX`, starts writing at index 0.
`double[]`	`getLimitPenalty(int start, double[] penalty)` Covers `getLimitPenalty(RX, int[], int, double[])`, uses `setLimitComponents` and `mobilityRX`.
`double[]`	`getLimitPenalty(vona.math.RX mobilityRX, int[] indices, int start, double[] penalty)` Impl of `getResidual(int, ResidualType, int, double[])` for `G_LIMIT`.
`double[]`	`getLimitPenalty(vona.math.RX mobilityRX, int start, double[] penalty)` Covers `getLimitPenalty(RX, int[], int, double[])`, uses `setLimitComponents`.
`double[]`	`getLimits(int which)` covers `getLimits(int, int, double[])`, conses and starts at 0
`double[]`	`getLimits(int which, double[] ret)` covers `getLimits(int, int, double[])`, starts at 0
`double[]`	`getLimits(int which, int start, double[] ret)` Get a copy of the `LOWER` or `UPPER` limits.
`double[]`	`getMobility(double[] dof)` `getDoF(int, int[], int, double[], boolean)` getting `RX_MOBILITY`, starting at 0, and always getting EM alias in limits.
`double[]`	`getMobility(int start, double[] dof, boolean getEMAliasInLimits)` `getDoF(int, int[], int, double[], boolean)` getting `RX_MOBILITY`.
`vona.math.RX`	`getMobility(vona.math.RX rx)` covers `getSubRX(int, RX)`, gets `RX_MOBILITY`
`double[][]`	`getMobilitydEMdQRef()` get a ref to the indicated cached quantity, recomputing if dirty
`double[]`	`getMobilityDoF()` `getDoF(int, int[], int, double[], boolean)` getting `RX_MOBILITY`, consing, and always getting EM alias in limits.
`double[][]`	`getMobilitydQdEMRef()` get a ref to the indicated cached quantity, recomputing if dirty
`double[][]`	`getMobilitydRdEMRef()` get a ref to the indicated cached quantity, recomputing if dirty
`double[][]`	`getMobilitydRdQRef()` get a ref to the indicated cached quantity, recomputing if dirty
`double[]`	`getMobilityQuaternionRef()` get a ref to the indicated cached quantity, recomputing if dirty
`double[]`	`getMobilityRotMatrixRef()` get a ref to the indicated cached quantity, recomputing if dirty
`vona.math.RX`	`getMobilityRX()` Covers `getSubRX(int, RX)`, gets `RX_MOBILITY` and conses.
`vona.math.RX`	`getMobilityRXClampedInverseRef()` get a ref to the indicated cached quantity, recomputing if dirty
`vona.math.RX`	`getMobilityRXInverseRef()` get a ref to the indicated cached quantity, recomputing if dirty
`double[]`	`getMobilityRXTranslation()` `getMobilityRXTranslation(double[])`, conses
`double[]`	`getMobilityRXTranslation(double[] translation)` get a copy of the translation part of `RX_MOBILITY`
`vona.math.RX`	`getMobilityToParent(vona.math.RX rx)` covers `getSubRX(int, RX)`, gets `RX_MOBILITY_TO_PARENT`
`vona.math.RX`	`getMobilityToParentRX()` Covers `getSubRX(int, RX)`, gets `RX_MOBILITY_TO_PARENT` and conses.
`protected java.lang.String[]`	`getNames(java.lang.String[] source, int writeStart, java.lang.String[] dest)` like `getIndices(int[], int, int[])` but gets TXEM component names
`protected java.lang.String`	`getNodeWidgetProperty()` Return the `Widget` property name that indicates an internal (i.e.
`int`	`getNumDoF()` get the number of Degrees of Freedom in the current `type`
`int`	`getNumDoI()` get the number of Degrees of Invariance in the current `type`
`int`	`getNumGoalComponentsSet(int which)` Get the number of TXEM components currently set for `RX_INVARIANT`, `RX_LOCK`, `RX_TARGET`, `RX_POSTURE`, or `G_LIMIT`.
`int`	`getNumRotationDoF()` get the number of rotational DoF in the current `type`
`int`	`getNumRotationGoalComponentsSet(int which)` Like `getNumGoalComponentsSet(int)` but only returns rotational components.
`int`	`getNumTranslationDoF()` get the number of translational DoF in the current `type`
`int`	`getNumTranslationGoalComponentsSet(int which)` Like `getNumGoalComponentsSet(int)` but only returns translational components.
`double[]`	`getPackedInvariantsRef()` Get the values of the Degrees of Invariance of the current Joint `type`, eliding DoF.
`LinkageNode`	`getParent()` returns `parentLink`
`Link`	`getParentLink()` get the current `parentLink`, null if none
`double[]`	`getParentMobilityCMTQuaternionRef()` get a ref to the indicated cached quantity, recomputing if dirty
`vona.math.RX`	`getParentMobilityCMTRef()` get a ref to the indicated cached quantity, recomputing if dirty
`double[]`	`getParentMobilityCMTRotMatrixRef()` get a ref to the indicated cached quantity, recomputing if dirty
`java.lang.String`	`getParentName()` Get the name of the current attached child and child subframe, if any, else null.
`java.lang.String`	`getParentSubFrame()` get the current `parentSubFrame`, null if none
`static java.lang.String`	`getParentSubFrameOf(int subXForm)` Get the name of the sub-frame to which the sub-transform subXForm attaches.
`double`	`getPotential()` like `getPotential(int)` but always auto-selects
`double`	`getPotential(int which)` Get the indicated potential energy value.
`int`	`getPotentialGoal()` Get the currently set potential goal, `PG_STIFFNESS` or `PG_GRAVITY`, or -1 if none.
`static java.lang.String`	`getPotentialGoalName(int which)` get the human readable name for the indicated potential goal
`double[]`	`getResidual(int which, Joint.ResidualType type)` Covers `getResidual(int, ResidualType, int, double[])`, starts at 0 and conses.
`double[]`	`getResidual(int which, Joint.ResidualType type, double[] residual)` Covers `getResidual(int, ResidualType, int, double[])`, starts at 0.
`double[]`	`getResidual(int which, Joint.ResidualType type, int start, double[] residual)` Compute a differential vector which will satisfy the specified goal when added to the current state of that goal.
`double[]`	`getRotation()` `getDoF(int, int[], int, double[], boolean)` getting `RX_MOBILITY` with EM ailias in limits, rotation DoF only.
`double[]`	`getRotation(double[] dof)` `getDoF(int, int[], int, double[], boolean)` getting `RX_MOBILITY` with EM ailias in limits, rotation DoF only.
`double[]`	`getRotation(int start, double[] dof)` `getDoF(int, int[], int, double[], boolean)` getting `RX_MOBILITY` with EM ailias in limits, rotation DoF only.
`int[]`	`getRotationDoFIndices()` `getRotationDoFIndices(int, int[])` starting at 0 and consing.
`int[]`	`getRotationDoFIndices(int[] indices)` `getRotationDoFIndices(int, int[])` starting at 0
`int[]`	`getRotationDoFIndices(int start, int[] indices)` similar to `getDoFIndices(int, int[])` but restricted to rotation
`int[]`	`getRotationDoFIndicesRef()` similar to `getDoFIndicesRef()` but restricted to rotation
`java.lang.String[]`	`getRotationDoFNames()` `getRotationDoFNames(int, String[])` starting at 0 and consing
`java.lang.String[]`	`getRotationDoFNames(int start, java.lang.String[] names)` like `getRotationDoFIndices(int, int[])` but gets TXEM component names
`java.lang.String[]`	`getRotationDoFNames(java.lang.String[] names)` `getRotationDoFNames(int, String[])` starting at 0
`int[]`	`getRotationDoIIndices()` `getRotationDoIIndices(int, int[])` starting at 0 and consing.
`int[]`	`getRotationDoIIndices(int[] indices)` `getRotationDoIIndices(int, int[])` starting at 0
`int[]`	`getRotationDoIIndices(int start, int[] indices)` similar to `getDoIIndices(int, int[])` but restricted to rotation
`int[]`	`getRotationDoIIndicesRef()` similar to `getDoIIndicesRef()` but restricted to rotation
`java.lang.String[]`	`getRotationDoINames()` `getRotationDoINames(int, String[])` starting at 0 and consing
`java.lang.String[]`	`getRotationDoINames(int start, java.lang.String[] names)` like `getRotationDoIIndices(int, int[])` but gets TXEM component names
`java.lang.String[]`	`getRotationDoINames(java.lang.String[] names)` `getRotationDoINames(int, String[])` starting at 0
`double`	`getRotationLimit(int component, int which)` similar to `getTranslationLimit(int, int)`
`java.lang.String[]`	`getSetGoalComponentNames(int which)` `getSetGoalComponentNames(int, int, String[])` starting at 0 and consing.
`java.lang.String[]`	`getSetGoalComponentNames(int which, int start, java.lang.String[] names)` like `getSetGoalComponents(int)` but gets TXEM component names
`java.lang.String[]`	`getSetGoalComponentNames(int which, java.lang.String[] names)` `getSetGoalComponentNames(int, int, String[])` starting at 0
`int[]`	`getSetGoalComponents(int which)` Get a ref to a cached array containing the indices of the currently set components for the indicated goal, `RX_INVARIANT`, `RX_LOCK`, `RX_TARGET`, `RX_POSTURE`, or `G_LIMIT`, if any.
`int[]`	`getSetRotationGoalComponents(int which)` Like `getSetGoalComponents(int)` but restricted to rotation components.
`int[]`	`getSetTranslationGoalComponents(int which)` Like `getSetGoalComponents(int)` but restricted to translation components.
`double`	`getSingleMobilityDoF()` get a ref to the indicated cached quantity, recomputing if dirty
`float`	`getSoftGoalPriority()` get the `softGoalPriority` of this Joint
`int`	`getSoftGoalSolveLevel()` get this Joint's `softGoalSolveLevel` in its `solver`
`double`	`getSoftGoalWeight()` get the `softGoalWeight` of this Joint
`Solver`	`getSolver()` get the `solver` assigned to this Joint
`double`	`getStiffness()` get `stiffness` or NaN if unset
`double`	`getStiffnessPotential()` Get the current potential energy stored in this Joint's `stiffness`, if any.
`double`	`getStiffnessPotential(double mobilityDoF)` Impl of `getStiffnessPotential()`.
`double`	`getStiffnessRest()` get `stiffnessRest`
`vona.math.RX`	`getSubFrameCMT(int subXForm)` `getSubFrameCMT(int, RX)`, conses
`vona.math.RX`	`getSubFrameCMT(int subXForm, vona.math.RX rx)` Convenience cover of `getSubFrameCMT(String, RX)` using `getParentSubFrameOf(int)`.
`vona.math.RX`	`getSubFrameCMT(java.lang.String frame, vona.math.RX rx)` Convenience method appends `LinkageNode.cmt` to `LinkageNode.getSubFrameRX(String, RX)`.
`vona.math.RX`	`getSubFrameCMT(java.lang.String frame, vona.math.RX rx, boolean clamped)` Convenience method appends `LinkageNode.cmt` to `getSubFrameRX(String, RX, boolean)`.
`vona.math.RX`	`getSubFrameRX(int subXForm)` `getSubFrameRX(int, RX)`, conses
`vona.math.RX`	`getSubFrameRX(int subXForm, vona.math.RX rx)` Convenience cover of `getSubFrameRX(String, RX)` using `getParentSubFrame()`.
`vona.math.RX`	`getSubFrameRX(java.lang.String frame, vona.math.RX rx)` Get the transform taking coordinates in a sub-frame to the canonical (i.e.
`vona.math.RX`	`getSubFrameRX(java.lang.String frame, vona.math.RX rx, boolean clamped)` Impl of `getSubFrameRX(String, RX)`.
`vona.math.RX`	`getSubRX(int which)` covers `getSubRX(int, RX)`, always conses
`vona.math.RX`	`getSubRX(int which, vona.math.RX rx)` Get a copy of one of the sub-transforms.
`static java.lang.String`	`getSubRXName(int which)` get the human readable name for the indicated subtransform
`vona.math.RX`	`getSubRXRef(int which)` Get a reference to one of the sub-transforms, do not modify.
`int`	`getSupportSize()` get the size of this Joint's `support` in its `solver`
`double[]`	`getTranslation()` `getDoF(int, int[], int, double[], boolean)` getting `RX_MOBILITY` translation DoF only.
`double[]`	`getTranslation(double[] dof)` `getDoF(int, int[], int, double[], boolean)` getting `RX_MOBILITY` translation DoF only.
`double[]`	`getTranslation(int start, double[] dof)` `getDoF(int, int[], int, double[], boolean)` getting `RX_MOBILITY` translation DoF only.
`int[]`	`getTranslationDoFIndices()` `getTranslationDoFIndices(int, int[])` starting at 0 and consing.
`int[]`	`getTranslationDoFIndices(int[] indices)` `getTranslationDoFIndices(int, int[])` starting at 0
`int[]`	`getTranslationDoFIndices(int start, int[] indices)` similar to `getDoFIndices(int, int[])` but restricted to translation
`int[]`	`getTranslationDoFIndicesRef()` similar to `getDoFIndicesRef()` but restricted to translation
`java.lang.String[]`	`getTranslationDoFNames()` `getTranslationDoFNames(int, String[])` starting at 0 and consing
`java.lang.String[]`	`getTranslationDoFNames(int start, java.lang.String[] names)` like `getTranslationDoFIndices(int, int[])` but gets TXEM component names
`java.lang.String[]`	`getTranslationDoFNames(java.lang.String[] names)` `getTranslationDoFNames(int, String[])` starting at 0
`int[]`	`getTranslationDoIIndices()` `getTranslationDoIIndices(int, int[])` starting at 0 and consing.
`int[]`	`getTranslationDoIIndices(int[] indices)` `getTranslationDoIIndices(int, int[])` starting at 0
`int[]`	`getTranslationDoIIndices(int start, int[] indices)` similar to `getDoIIndices(int, int[])` but restricted to translation
`int[]`	`getTranslationDoIIndicesRef()` similar to `getDoIIndicesRef()` but restricted to translation
`java.lang.String[]`	`getTranslationDoINames()` `getTranslationDoINames(int, String[])` starting at 0 and consing
`java.lang.String[]`	`getTranslationDoINames(int start, java.lang.String[] names)` like `getTranslationDoIIndices(int, int[])` but gets TXEM component names
`java.lang.String[]`	`getTranslationDoINames(java.lang.String[] names)` `getTranslationDoINames(int, String[])` starting at 0
`double`	`getTranslationLimit(int component, int which)` Get the `LOWER` or `UPPER` limit of one component of the mobility translation vector.
`Joint.Type`	`getType()` get the current Joint `Joint.Type`
`java.lang.String`	`getTypeName()` returns the lower-cased name of this Joint's `type`
`int[]`	`getUnsetGoalComponents(int which)` complimentary to `getSetGoalComponents(int)`
`protected boolean`	`handleMobilityChange()` `handleMobilityChange(boolean)` and clamp `mobilityRX` iff `isTreeJoint()` or not `isConnected()`.
`protected boolean`	`handleMobilityChange(boolean overwriteIfClamped)` Hook called whenever `mobilityRX` or the mobility space has changed.
`boolean`	`hasAnyGoal()` Check if any component of any goal is currently set or `hasPotential()` or `isDoFLimited()`.
`boolean`	`hasChildren()` check whether this node has any children
`boolean`	`hasEitherSoftGoal()` Check if either `RX_TARGET` or `RX_POSTURE` is currently set.
`boolean`	`hasGoal(int which)` check if a goal is currently set
`boolean`	`hasGravity()` Check if this Joint has gravity.
`boolean`	`hasInvariant()` `hasGoal(int)` `RX_INVARIANT`
`boolean`	`hasLock()` `hasGoal(int)` `RX_LOCK`
`boolean`	`hasPosture()` `hasGoal(int)` `RX_POSTURE`
`boolean`	`hasPotential()` check either `hasStiffness()` or `hasGravity()`
`boolean`	`hasStiffness()` Check if this Joint has stiffness.
`boolean`	`hasSubFrame(java.lang.String frame)` Check if the named subframe is present.
`boolean`	`hasTarget()` `hasGoal(int)` `RX_TARGET`
`boolean`	`inDoFLimits()` `inDoFLimits(double)`, no tol
`boolean`	`inDoFLimits(double tol)` Check if the current mobility transform is actually within the `limit`s.
`Joint`	`invert()` Invert both the topology and the geometry of this Joint.
`boolean`	`isActuator()` check if this Joint is an actuator in its `solver`
`boolean`	`isBroken()` check if this breaks DoI or DoF limits (using `BROKEN_TOL`)
`static boolean`	`isChainSubtransform(int which)` check if the indicated sub-transform is in the child-to-parent chain
`boolean`	`isChildToMobilityIdentity()` check `RX.isIdentity()` on `childToMobilityRX`
`boolean`	`isClosureJoint()` Checks not `isTreeJoint()`, i.e.
`boolean`	`isConnected()` check if both `parentLink` and `childLink` are set
`boolean`	`isCrossing()` Check if `isIncrossing()` or `isOutcrossing()`.
`boolean`	`isDoF(int component)` check if a TXEM component is a DoF
`boolean`	`isDoF(int component, int offset)` Common impl of `isTranslationDoF(int)` and `isRotationDoF(int)`.
`boolean`	`isDoFLimited()` Check whether any of the DoF of this joint are limited.
`boolean`	`isDoI(int component)` check if a TXEM component is a DoI
`boolean`	`isDoI(int component, int offset)` Common impl of `isTranslationDoI(int)` and `isRotationDoI(int)`.
`boolean`	`isEffector()` Check if this Joint is an effector of any type in its `solver`.
`boolean`	`isEffector(int which)` Check if this Joint is an effector of the given type (`RX_INVARIANT`, `G_LIMIT`, `RX_LOCK`, `RX_TARGET`, `RX_POSTURE`, or `PG_POTENTIAL`) in its `solver`.
`static boolean`	`isGoalSubtransform(int which)` check if the indicated sub-transform is a goal
`static boolean`	`isHardGoalSubtransform(int which)` check if the indicated sub-transform is a hard goal
`boolean`	`isIdentity()` check `RX.isIdentity()` on `jointRX`
`boolean`	`isIncrossing()` Check if `childLink` is not null and is not in `LinkageNode.linkage`.
`boolean`	`isInternalFrame(java.lang.String frame)` Check if frame is an internal (i.e.
`boolean`	`isLimited()` check if there are any DoI or if there are limits are set on any DoF
`boolean`	`isLimited(int component)` check if a TXEM component is limited
`boolean`	`isLimited(int component, int offset)` Common impl of `isTranslationLimited(int)` and `isRotationLimited(int)`.
`static boolean`	`isLimitGoal(int which)` check if which indicates the limit goal
`boolean`	`isLocked()` check if this node is locked
`boolean`	`isMobilityIdentity()` check `RX.isIdentity()` on `mobilityRX`
`boolean`	`isMobilityInverted()` check if `mobilityInverted`
`static boolean`	`isMobilitySpaceSubtransform(int which)` Check if the indicated sub-transform is `RX_MOBILITY` or a hard or soft goal.
`boolean`	`isMobilityToParentIdentity()` check `RX.isIdentity()` on `mobilityToParentRX`
`boolean`	`isOutcrossing()` Check if `parentLink` is not null and is not in `LinkageNode.linkage`.
`static boolean`	`isPositioningSubtransform(int which)` check if the indicated sub-transform positions the mobility space
`boolean`	`isPotentialEnabled()` check potential goal gating enable
`static boolean`	`isPotentialGoal(int goal)` Check if goal is one of the potential goals `PG_POTENTIAL` (itself a meta-goal), `PG_STIFFNESS`, or `PG_GRAVITY`.
`boolean`	`isRotationDoF(int component)` similar to `isTranslationDoF(int)`
`boolean`	`isRotationDoI(int component)` similar to `isTranslationDoI(int)`
`boolean`	`isRotationLimited(int component)` similar to `isTranslationLimited(int)`
`static boolean`	`isSoftGoalSubtransform(int which)` check if the indicated sub-transform is a soft goal
`boolean`	`isStiffnessSet()` Check if `stiffness` is set (not NaN).
`boolean`	`isTranslationDoF(int component)` Check if a given translation vector component is a Degree of Freedom according to the current Joint `type`.
`boolean`	`isTranslationDoI(int component)` Check if a given translation vector component is a Degree of Invariance according to the current Joint `type`.
`boolean`	`isTranslationLimited(int component)` Check if one component of the mobility translation vector currently has limits set.
`boolean`	`isTreeJoint()` Checks if we have a `childLink` and its `Link.parentJoint` is this Joint.
`boolean`	`isTreeLeaf()` Check if this is a leaf in the model tree.
`Joint`	`lockPositioningTransforms()` covers `setPositioningTransformsLocked(boolean)`
`Joint`	`makeClosureJoint()` Ensure that this Joint is a chain closure.
`Joint`	`makeTreeJoint()` Ensure that this Joint is a tree joint iff it's connected.
`Link`	`merge()` Covers `merge(boolean, boolean)`, reparents both Joint and `Link` user widgets.
`Link`	`merge(boolean reparentWidgets)` Covers `merge(boolean, boolean)`, reparents both Joint and `Link` user widgets or not.
`Link`	`merge(boolean reparentUserJointWidgets, boolean reparentUserLinkWidgets)` `remove()` this Joint and its child `Link` from the model, re-attaching joints that were attached to the child Link to our parent Link.
`static int`	`otherPositioningTransform(int which)` return the opposite mobility space positioning transform
`boolean`	`positioningTransformsMutable()` Check if `RX_CHILD_TO_MOBILITY` and `RX_MOBILITY_TO_PARENT` are mutable.
`boolean`	`recomputeInverse()` Covers `recomputeInverse(int, boolean)`, always recomputes `jointRX` and puts the slack in `RX_MOBILITY`.
`boolean`	`recomputeInverse(int slackTransform)` Covers `recomputeInverse(int, boolean)`, always recomputes `jointRX`.
`boolean`	`recomputeInverse(int slackTransform, boolean recomputeJointRX)` Possibly recompute `jointRX` to fit the current `parentLink` and `childLink` `LinkageNode.cmt`s, then recompute one of the three internal transforms `RX_MOBILITY`, `RX_CHILD_TO_MOBILITY`, or `RX_MOBILITY_TO_PARENT` to take up the slack left by the other two incomposing (the new) `jointRX`.
`protected boolean`	`recomputeInverse(vona.math.RX slackRX)` Recompute the indicated slackRX based on the current jointRX.
`protected boolean`	`recomputeInverse(vona.math.RX slackRX, vona.math.RX parentCMT, vona.math.RX childCMT)` Recompute `jointRX` from the given adjacent `Link` CMTs, then recompute the indicated slackRX.
`void`	`recomputeJointRX()` Recompute `jointRX` from `childToMobilityRX`, `mobilityRX`, and `mobilityToParentRX`.
`void`	`remove()` Remove this node from the `Linkage` tree.
`void`	`resetSolveFields()` reset/null `solver` and related fields
`boolean`	`setAllDoFLimits(double... limits)` similar to `setAllTranslationLimits(double...)`
`boolean`	`setAllRotationLimits(double... limits)` similar to `setAllTranslationLimits(double...)`
`boolean`	`setAllTranslationLimits(double... limits)` Set the `LOWER` and `UPPER` limits for all translation DoF.
`Link`	`setChildLink(Link childLink)` `setChildLink(Link, boolean)`, does not request holding absolute pose.
`Link`	`setChildLink(LinkageNode.SubFrame child)` Covers `setChildLink(Link, String)`.
`Link`	`setChildLink(LinkageNode.SubFrame child, boolean holdAbsolutePose)` Covers `setChildLink(Link, String, boolean)`.
`Link`	`setChildLink(Link childLink, boolean holdAbsolutePose)` `setChildLink(Link, String, boolean)`, does not attach to subframe.
`Link`	`setChildLink(Link childLink, java.lang.String childSubFrame)` `setChildLink(Link, String, boolean)`, does not request holding absolute pose.
`Link`	`setChildLink(Link childLink, java.lang.String childSubFrame, boolean holdAbsolutePose)` Mutate the `childLink`.
`void`	`setChildToMobility(Link child)` `recomputeInverse(int)` as if our child was child and put the slack in `RX_CHILD_TO_MOBILITY`.
`void`	`setChildToMobility(vona.math.RX rx)` `setSubRX(int, RX)` on `RX_CHILD_TO_MOBILITY`
`boolean`	`setDoF(double... dof)` `setDoF(int, int[], int, double...)` all `Joint.Type.dofIndex` starting at 0 and setting `RX_MOBILITY`.
`boolean`	`setDoF(int which, int[] dofIndex, double... dof)` `setDoF(int, int[], int, double...)` starting at 0
`boolean`	`setDoF(int which, int[] dofIndex, int start, double... dof)` Set the Degree of Freedom values of the `RX_TARGET`, `RX_LOCK`, `RX_POSTURE`, or `RX_MOBILITY` `RX` treated as a packed translation and exponential map vector.
`protected boolean`	`setLimits(int component, int offset, java.lang.String name, double min, double max)` Common impl of `setTranslationLimits(int, double, double)` and `setRotationLimits(int, double, double)`.
`boolean`	`setLock(double... dof)` `setDoF(int, int[], int, double...)` on `RX_LOCK`
`LinkageNode`	`setLocked(boolean locked)` lock the state of this node
`boolean`	`setLockRotation(double... dof)` Like `setDoF(int, int[], int, double...)` on `RX_LOCK` but only sets EM rotation components.
`Joint`	`setLockToMobility()` opposite of `setMobilityToLock()`
`boolean`	`setLockTranslation(double... dof)` Like `setDoF(int, int[], int, double...)` on `RX_LOCK` but only sets translation components.
`boolean`	`setMobility(vona.math.RX rx)` `setSubRX(int, RX)` on `RX_MOBILITY`
`boolean`	`setMobilityDoF(double... dof)` `setMobilityDoF(int[], int, double...)` all `Joint.Type.dofIndex` starting at 0.
`boolean`	`setMobilityDoF(int[] dofIndex, double... dof)` `setMobilityDoF(int[], int, double...)` starting at 0
`boolean`	`setMobilityDoF(int[] dofIndex, int start, double... dof)` Impl of `setDoF(int, int[], int, double...)` for setting `RX_MOBILITY`.
`boolean`	`setMobilityDoF(int start, double... dof)` `setMobilityDoF(int[], int, double...)` sets all DoF
`Joint`	`setMobilityToGoal(int which)` Set `mobilityRX` to the current value of the indicated goal.
`Joint`	`setMobilityToGravityRest()` Set the mobility DoF to zero gravitational potential energy stored in this joint.
`Joint`	`setMobilityToInvariant()` `setMobilityToGoal(int)` `RX_INVARIANT`
`Joint`	`setMobilityToLock()` `setMobilityToGoal(int)` `RX_LOCK`
`void`	`setMobilityToParent(Link parent)` `recomputeInverse(int)` as if our parent was parent and put the slack in `RX_MOBILITY_TO_PARENT`.
`void`	`setMobilityToParent(vona.math.RX rx)` `setSubRX(int, RX)` on `RX_MOBILITY_TO_PARENT`
`Joint`	`setMobilityToPosture()` `setMobilityToGoal(int)` `RX_POSTURE`
`Joint`	`setMobilityToStiffnessRest()` Set the mobility DoF to the `stiffnessRest`.
`Joint`	`setMobilityToTarget()` `setMobilityToGoal(int)` `RX_TARGET`
`java.lang.String`	`setName(java.lang.String name)` Set the name of this Joint.
`Link`	`setParentLink(Link parentLink)` `setParentLink(Link, boolean)`, does not request holding absolute pose.
`Link`	`setParentLink(LinkageNode.SubFrame parent)` Covers `setParentLink(Link, String)`.
`Link`	`setParentLink(LinkageNode.SubFrame parent, boolean holdAbsolutePose)` Covers `setParentLink(Link, String, boolean)`.
`Link`	`setParentLink(Link parentLink, boolean holdAbsolutePose)` `setParentLink(Link, String, boolean)`, does not attach to subframe.
`Link`	`setParentLink(Link parentLink, java.lang.String parentSubFrame)` `setParentLink(Link, String, boolean)`, does not request holding absolute pose.
`Link`	`setParentLink(Link parentLink, java.lang.String parentSubFrame, boolean holdAbsolutePose)` Mutate the `parentLink`.
`Joint`	`setPositioningTransformsLocked(boolean lock)` Flag `RX_CHILD_TO_MOBILITY` and `RX_MOBILITY_TO_PARENT` as locked or unlocked.
`boolean`	`setPosture(double... dof)` `setSoftGoalDoF(int, double...)` on `RX_POSTURE`
`boolean`	`setPostureRotation(double... dof)` Like `setDoF(int, int[], int, double...)` on `RX_POSTURE` but only sets EM rotation components.
`Joint`	`setPostureToMobility()` covers `setSoftGoalToMobility(int)`
`boolean`	`setPostureTranslation(double... dof)` Like `setDoF(int, int[], int, double...)` on `RX_POSTURE` but only sets translation components.
`boolean`	`setPotentialEnabled(boolean enabled)` Enable or disable potential goal, if any.
`boolean`	`setRotation(double... dof)` Like `setMobilityDoF(double...)` but only sets EM rotation components.
`boolean`	`setRotationLimits(int component, double min, double max)` Similar to `setTranslationLimits(int, double, double)`.
`boolean`	`setSoftGoal(int which, vona.math.RX rx)` `setSubRX(int, RX)` on `RX_TARGET` or `RX_POSTURE`.
`boolean`	`setSoftGoalDoF(int which, double... dof)` `setSoftGoalDoF(int, int[], boolean, boolean, int, double...)` all `Joint.Type.dofIndex` even if not different from current mobility, starting at 0.
`boolean`	`setSoftGoalDoF(int which, int[] dofIndex, boolean partial, boolean onlyIfDifferent, double... dof)` `setSoftGoalDoF(int, int[], boolean, boolean, int, double...)` starting at 0.
`boolean`	`setSoftGoalDoF(int which, int[] dofIndex, boolean partial, boolean onlyIfDifferent, int start, double... dof)` Impl of `setDoF(int, int[], int, double...)` and other APIs for setting `RX_TARGET` or `RX_POSTURE` DoF.
`boolean`	`setSoftGoalDoF(int which, int[] dofIndex, double... dof)` `setSoftGoalDoF(int, int[], boolean, boolean, int, double...)` partial but even if not different from current mobility, starting at 0.
`Joint`	`setSoftGoalPriority(float priority)` set the `softGoalPriority` of this Joint
`boolean`	`setSoftGoalRX(int which, int[] dofIndex, boolean partial, boolean onlyIfDifferent, vona.math.RX rx, vona.math.RX compareUnsetComponentsTo)` Like `setSoftGoalDoF(int, int[], boolean, boolean, int, double...)` but reads source values from an `RX`.
`protected boolean`	`setSoftGoalRXOrDoF(int which, int[] dofIndex, boolean partial, boolean onlyIfDifferent, int start, java.lang.Object rxOrDoF, vona.math.RX compareUnsetComponentsTo)` Common impl of `setSoftGoalDoF(int, int[], boolean, boolean, int, double...)` and `setSoftGoalRX(int, int[], boolean, boolean, RX, RX)`.
`Joint`	`setSoftGoalToMobility(int which)` Opposite of `setMobilityToGoal(int)`.
`Joint`	`setSoftGoalWeight(double weight)` set the `softGoalWeight` of this Joint
`double`	`setStiffness(double stiffness)` Set the joint stiffness.
`boolean`	`setStiffnessRest(double stiffnessRest)` Set `stiffnessRest`.
`Joint`	`setStiffnessRestToMobility()` Set `stiffnessRest` to the current mobility DoF.
`boolean`	`setSubRX(int which, int slackRX, vona.math.RX rx)` Set one of the sub-transforms.
`boolean`	`setSubRX(int which, vona.math.RX rx)` `setSubRX(int, int, RX)` recomputing `jointRX`.
`boolean`	`setTarget(double... dof)` `setSoftGoalDoF(int, double...)` on `RX_POSTURE`
`boolean`	`setTargetRotation(double... dof)` Like `setDoF(int, int[], int, double...)` on `RX_TARGET` but only sets EM rotation components.
`Joint`	`setTargetToMobility()` covers `setSoftGoalToMobility(int)`
`boolean`	`setTargetTranslation(double... dof)` Like `setDoF(int, int[], int, double...)` on `RX_TARGET` but only sets translation components.
`boolean`	`setTranslation(double... dof)` Like `setMobilityDoF(double...)` but only sets translation components.
`boolean`	`setTranslationLimits(int component, double min, double max)` Set or un-set the upper and lower limits for one component of the mobility translation vector.
`Joint.Type`	`setType(Joint.Type type)` Mutate the `type` of this Joint.
`protected Joint.Type`	`setTypeImpl(Joint.Type type)` Impl of `setType(msim.model.Joint.Type)`, so that `RootJoint` constr can set initial type but still disable run-time type mutation.
`double[]`	`setUnsetGoalDoFtoNaN(int which, double[] dof)` Set all components of dof that correspond to unset DoF of goal which to NaN.
`java.lang.String`	`toString(boolean details)` covers `toString(boolean, boolean)`, always shows connections
`java.lang.String`	`toString(boolean details, boolean connections)` returns a short human-readable identifying string for this Joint
`Joint`	`transformMobility(vona.math.RX rx)` `transformMobility(RX, String)` in `SF_PARENT_MOBILITY`
`Joint`	`transformMobility(vona.math.RX rx, java.lang.String inSubFrame)` Transform the mobility frames relative to the given frame.
`java.lang.String`	`unAliasSubFrame(java.lang.String subFrame)` Dereference `SF_MOBILITY_FROM` and `SF_MOBILITY_TO` according to the current value of `mobilityInverted`.
`Joint`	`unlockPositioningTransforms()` covers `setPositioningTransformsLocked(boolean)`
`Joint`	`unsetAllDoFLimits()` similar to `unsetAllTranslationLimits()`
`Joint`	`unsetAllRotationLimits()` similar to `unsetAllTranslationLimits()`
`Joint`	`unsetAllTranslationLimits()` `unsetTranslationLimits(int)` all translation DoF
`Joint`	`unsetLock()` chains to `setLocked(boolean)`
`Joint`	`unsetPosture()` `unsetSoftGoal(int)` `RX_POSTURE`
`Joint`	`unsetRotationLimits(int component)` similar to `unsetTranslationLimits(int)`
`Joint`	`unsetSoftGoal(int which)` un-set current `RX_TARGET` or `RX_POSTURE`
`Joint`	`unsetSoftGoals()` un-set both `RX_TARGET` or `RX_POSTURE`
`double`	`unsetStiffness()` `setStiffness(double)` NaN
`Joint`	`unsetTarget()` `unsetSoftGoal(int)` `RX_TARGET`
`Joint`	`unsetTranslationLimits(int component)` covers `setTranslationLimits(int, double, double)`, always un-sets
`protected void`	`updateAxesWidget(vona.j3d.AxesWidget w, java.lang.String frame)` Enables or disables the axes depending on whether the corresponding transform is identity, whether the Joint is connected, and if so whether it is attached to a `Link` subframe.
`protected void`	`updateAxesWidget(java.lang.String name, java.lang.String frame)` Retrieves the named `AxesWidget` and calls `updateAxesWidget(AxesWidget, String)`.
`protected void`	`updateCircleWidget()` Retrieves `WN_JOINT_CIRCLE` and calls `updateSliderWidget(vona.j3d.EdgedFacetedWidget)`.
`void`	`updateCMTs()` Update this node's `LinkageNode.cmt` based on its parent's `LinkageNode.cmt`.
`protected void`	`updateCylinderWidget()` Retrieves `WN_JOINT_CYLINDER` and calls `updateCylinderWidget(CylinderWidget)`.
`protected void`	`updateCylinderWidget(vona.j3d.CylinderWidget w)` Sets the extents of w along the z axis, and the edge pattern of w depending on the current z translation limits, if any.
`protected boolean`	`updateGoalFromMobility(int which)` Update any un-set TXEM components of goal which from `mobilityRX` and clamp it to current `limit`s.
`protected void`	`updatePrismWidgets(int axis, float extraMargin)` Retrieves `WN_JOINT_PRISM` and `WN_JOINT_PRISM_ENDS` and calls `updatePrismWidgets(PrismWidget, PrismWidget, int, float)`.
`protected void`	`updatePrismWidgets(vona.j3d.PrismWidget w, vona.j3d.PrismWidget cw, int axis, float extraMargin)` Sets the extents of w and cw along axis, and the edge pattern of cw depending on the current limits for axis, if any.
`protected void`	`updateRectangleWidgets(float extraMargin)` Retrieves `WN_JOINT_RECTANGLE` and `WN_JOINT_RECTANGLE_Y_EDGES` and calls `updateRectangleWidgets(RectangleWidget, RectangleWidget, float)`.
`protected void`	`updateRectangleWidgets(vona.j3d.RectangleWidget w, vona.j3d.RectangleWidget yw, float extraMargin)` Sets the extents of w and yw, and the edge patterns depending on the current limits for the X and Y axes, if any.
`protected void`	`updateRouteWidgets(vona.j3d.RouteWidget rw, vona.j3d.ConeWidget cw, java.lang.String frame, int rx)` Enables or disables the route widgets, and updates their geometry.
`protected void`	`updateRouteWidgets(java.lang.String name, java.lang.String frame, int rx)` Retrieves the named route widgets and calls `updateRouteWidgets(RouteWidget, ConeWidget, String, int)`.
`protected void`	`updateSectorWidgets()` Retrieves `WN_JOINT_SECTOR` and `WN_JOINT_SECTOR_ENDS` and calls `updateSectorWidgets(SectorWidget, SectorWidget)`.
`protected void`	`updateSectorWidgets(vona.j3d.SectorWidget w, vona.j3d.SectorWidget ew)` Sets the lengths and angles of w and ew, their translation in `SF_MOBILITY_TO`, and the edge pattern of ew depending on the current Z axis rotation limits, if any.
`protected void`	`updateSegmentWidget()` Retrieves `WN_JOINT_SEGMENT` and calls `updateSliderWidget(vona.j3d.EdgedFacetedWidget)`.
`protected void`	`updateSliderWidget(vona.j3d.CurveWidget w)` sets color depending on whether the joint is `locked`
`protected void`	`updateSliderWidget(vona.j3d.EdgedFacetedWidget w)` sets color depending on whether the joint is `locked`
`protected void`	`updateSphereWidget()` Retrieves `WN_JOINT_SPHERE` and calls `updateSphereWidget()`.
`protected void`	`updateSphereWidget(vona.j3d.SphereWidget w)` updates widget rx
`protected void`	`updateSquareWidget()` Retrieves `WN_JOINT_SQUARE` and calls `updateSliderWidget(vona.j3d.EdgedFacetedWidget)`.
`protected void`	`updateWidgetsImpl()` Hook for lazy `LinkageNode.widgetMap` update.

Methods inherited from class msim.model.LinkageNode
addWidget, addWidget, addWidget, addWidget, addWidget, addWidget, checkNamePattern, collectTreeMetrics, collectTreeMetrics, compareTo, dump, dumpSubFrames, dumpTree, dumpTree, dumpTreeMetrics, dumpTreeMetrics, enableDBGNormals, enableDBGNormalsRecursively, enableDBGSpheres, enableDBGSpheresRecursively, findImpl, findJoint, findJoint, findJoints, findJoints, findLink, findLink, findLinks, findLinks, findMultipleImpl, findNode, findNode, findNodes, findNodes, getCMT, getCMT, getDepth, getName, getNumUserWidgets, getNumWidgets, getProperty, getSubFrame, getSubFrame, getSubFrameCMT, getSubFrameCMT, getSubFrameCMT, getSubFrameName, getSubFrameRX, getSubFrameRX, getSubFrameRX, getWidget, getWidgetLength, getWidgets, hasDescendant, hasProperty, hasWidgets, isAutoNamed, isExplicitlyHidden, isExplicitlyHighlighted, isExplicitlyMasked, isExplicitlyVisible, isLive, isUserWidget, lock, removeAllWidgets, removeProperty, removeWidget, removeWidget, renameWidget, reparentUserWidgets, reparentUserWidgets, reparentWidget, reparentWidget, reparentWidgetImpl, reparentWidgets, reparentWidgets, setAllTreeJointsToGoal, setAllTreeJointsToHighestPrioritySoftGoal, setAllTreeJointsToPosture, setAllTreeJointsToTarget, setExplicitlyHidden, setExplicitlyHighlighted, setExplicitlyMasked, setExplicitlyVisible, setLockedRecursively, setProperty, setProperty, setWidgetLength, setWidgetLength, setWidgetLengthRecursively, setWidgetLengthRecursively, suppressTreeDump, toString, traverseTree, unlock, updateCMTsRecursively, updateWidgets, updateWidgetsRecursively

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

- Field Detail
  - cvsid
```
private static final java.lang.String cvsid
```
    See Also:
    Constant Field Values
  - FMT_WIDTH
```
public static final int FMT_WIDTH
```
    field width for FMT
    
    See Also:
    Constant Field Values
  - FMT
```
public static final java.lang.String FMT
```
    decimal printf format
    
    See Also:
    Constant Field Values
  - FMT_S
```
public static final java.lang.String FMT_S
```
    string printf format same width as FMT
    
    See Also:
    Constant Field Values
  - FMT3
```
public static final java.lang.String FMT3
```
    multiple FMTs
    
    See Also:
    Constant Field Values
  - FMT4
```
public static final java.lang.String FMT4
```
    multiple FMTs
    
    See Also:
    Constant Field Values
  - FMT6
```
public static final java.lang.String FMT6
```
    multiple FMTs
    
    See Also:
    Constant Field Values
  - FMT3_S
```
public static final java.lang.String FMT3_S
```
    multiple FMT_Ss
    
    See Also:
    Constant Field Values
  - FMT4_S
```
public static final java.lang.String FMT4_S
```
    multiple FMT_Ss
    
    See Also:
    Constant Field Values
  - FMT6_S
```
public static final java.lang.String FMT6_S
```
    multiple FMT_Ss
    
    See Also:
    Constant Field Values
  - WP_JOINT
```
public static final java.lang.String WP_JOINT
```
    Widget property identifying a Joint widget
    
    See Also:
    Constant Field Values
  - WP_ROUTE
```
public static final java.lang.String WP_ROUTE
```
    Widget property identifying the RouteWidget to which this widget is associated.
    
    See Also:
    Constant Field Values
  - SF_CHILD
```
public static final java.lang.String SF_CHILD
```
    Subframes.
    
    When not mobilityInverted, SF_MOBILITY_FROM is an alias for SF_CHILD_MOBILITY and SF_MOBILITY_TO is an alias for SF_PARENT_MOBILITY. But when mobilityInverted the aliases are swapped.
    
    See Also:
    Constant Field Values
  - SF_CHILD_MOBILITY
```
public static final java.lang.String SF_CHILD_MOBILITY
```
    Subframes.
    
    When not mobilityInverted, SF_MOBILITY_FROM is an alias for SF_CHILD_MOBILITY and SF_MOBILITY_TO is an alias for SF_PARENT_MOBILITY. But when mobilityInverted the aliases are swapped.
    
    See Also:
    Constant Field Values
  - SF_PARENT_MOBILITY
```
public static final java.lang.String SF_PARENT_MOBILITY
```
    Subframes.
    
    When not mobilityInverted, SF_MOBILITY_FROM is an alias for SF_CHILD_MOBILITY and SF_MOBILITY_TO is an alias for SF_PARENT_MOBILITY. But when mobilityInverted the aliases are swapped.
    
    See Also:
    Constant Field Values
  - SF_PARENT
```
public static final java.lang.String SF_PARENT
```
    Subframes.
    
    When not mobilityInverted, SF_MOBILITY_FROM is an alias for SF_CHILD_MOBILITY and SF_MOBILITY_TO is an alias for SF_PARENT_MOBILITY. But when mobilityInverted the aliases are swapped.
    
    See Also:
    Constant Field Values
  - SF_MOBILITY_FROM
```
public static final java.lang.String SF_MOBILITY_FROM
```
    Subframes.
    
    When not mobilityInverted, SF_MOBILITY_FROM is an alias for SF_CHILD_MOBILITY and SF_MOBILITY_TO is an alias for SF_PARENT_MOBILITY. But when mobilityInverted the aliases are swapped.
    
    See Also:
    Constant Field Values
  - SF_MOBILITY_TO
```
public static final java.lang.String SF_MOBILITY_TO
```
    Subframes.
    
    When not mobilityInverted, SF_MOBILITY_FROM is an alias for SF_CHILD_MOBILITY and SF_MOBILITY_TO is an alias for SF_PARENT_MOBILITY. But when mobilityInverted the aliases are swapped.
    
    See Also:
    Constant Field Values
  - JOINT_SUBFRAMES
```
public static final java.lang.String[] JOINT_SUBFRAMES
```
    all joint subframes
  - WIDGET_MARGIN
```
public static final float WIDGET_MARGIN
```
    Joint extendable Widget margin relative to LinkageNode.widgetLength. This extends the length of cylinder, prism, and plane widgets beyond the current mobility state when the corresponding DoF is unlimited.
    
    See Also:
    Constant Field Values
  - SECTOR_MARGIN
```
public static final float SECTOR_MARGIN
```
    Joint extendable SectorWidget margin in radians. This extends the angular extents of sector widgets beyond the current mobility state when the Z rotation DoF is unlimited.
  - SEGMENT_OFFSET_FACTOR
```
public static final float SEGMENT_OFFSET_FACTOR
```
    Joint segment and sector Widget lengths relative to LinkageNode.widgetLength.
    
    See Also:
    Constant Field Values
  - SEGMENT_LENGTH_FACTOR
```
public static final float SEGMENT_LENGTH_FACTOR
```
    Joint segment and sector Widget lengths relative to LinkageNode.widgetLength.
    
    See Also:
    Constant Field Values
  - SECTOR_OFFSET_FACTOR
```
public static final float SECTOR_OFFSET_FACTOR
```
    Joint segment and sector Widget lengths relative to LinkageNode.widgetLength.
    
    See Also:
    Constant Field Values
  - SECTOR_WIDTH_FACTOR
```
public static final float SECTOR_WIDTH_FACTOR
```
    Joint segment and sector Widget lengths relative to LinkageNode.widgetLength.
    
    See Also:
    Constant Field Values
  - WIDGET_WIDTH_FACTOR
```
public static final float WIDGET_WIDTH_FACTOR
```
    Joint prism and square Widget widths relative to LinkageNode.widgetLength.
    
    See Also:
    Constant Field Values
  - REVOLUTE_SECTOR_ALPHA
```
public static final float REVOLUTE_SECTOR_ALPHA
```
    Joint revolute/cylindrical/pin-slider sector, pin-slider/point-slider prism, and planar/point-plane rectangle Widget face alphas.
    
    See Also:
    Constant Field Values
  - SLIDER_PRISM_ALPHA
```
public static final float SLIDER_PRISM_ALPHA
```
    Joint revolute/cylindrical/pin-slider sector, pin-slider/point-slider prism, and planar/point-plane rectangle Widget face alphas.
    
    See Also:
    Constant Field Values
  - PLANAR_RECTANGLE_ALPHA
```
public static final float PLANAR_RECTANGLE_ALPHA
```
    Joint revolute/cylindrical/pin-slider sector, pin-slider/point-slider prism, and planar/point-plane rectangle Widget face alphas.
    
    See Also:
    Constant Field Values
  - LIMITED_EDGE_PATTERN
```
public static final int LIMITED_EDGE_PATTERN
```
    edge pattern for indicating limited or unlimited mobility
    
    See Also:
    Constant Field Values
  - UNLIMITED_EDGE_PATTERN
```
public static final int UNLIMITED_EDGE_PATTERN
```
    edge pattern for indicating limited or unlimited mobility
    
    See Also:
    Constant Field Values
  - LIMITED_EDGE_WIDTH
```
public static final float LIMITED_EDGE_WIDTH
```
    edge width for indicating limited or unlimited mobility
    
    See Also:
    Constant Field Values
  - UNLIMITED_EDGE_WIDTH
```
public static final float UNLIMITED_EDGE_WIDTH
```
    edge width for indicating limited or unlimited mobility
    
    See Also:
    Constant Field Values
  - SLIDER_EDGE_WIDTH
```
public static final float SLIDER_EDGE_WIDTH
```
    slider widget edge width
    
    See Also:
    Constant Field Values
  - CYLINDER_HEIGHT_FACTOR
```
public static final float CYLINDER_HEIGHT_FACTOR
```
    Joint cylinder Widget height relative to LinkageNode.widgetLength
    
    See Also:
    Constant Field Values
  - AXES_RADIUS_FACTOR
```
public static final float AXES_RADIUS_FACTOR
```
    Joint AxesWidget radius relative to LinkageNode.widgetLength
    
    See Also:
    Constant Field Values
  - WIDGET_RADIUS_FACTOR
```
public static final float WIDGET_RADIUS_FACTOR
```
    Joint cylinder, sphere, and circle Widget radii relative to LinkageNode.widgetLength.
    
    See Also:
    Constant Field Values
  - WIDGET_NUM_SECTORS
```
public static final int WIDGET_NUM_SECTORS
```
    Joint cylinder, sphere, and circle Widget sector counts
    
    See Also:
    Constant Field Values
  - ROUTE_TANGENT_FACTOR
```
public static final float ROUTE_TANGENT_FACTOR
```
    RouteWidget endpoint tangent lengths relative to LinkageNode.widgetLength.
    
    See Also:
    Constant Field Values
  - DEGENERATE_ROUTE_TANGENT_FACTOR
```
public static final float DEGENERATE_ROUTE_TANGENT_FACTOR
```
    RouteWidget endpoint tangent lengths relative to LinkageNode.widgetLength.
    
    See Also:
    Constant Field Values
  - ROUTE_LINE_WIDTH
```
public static final float ROUTE_LINE_WIDTH
```
    line width for RouteWidgets
    
    See Also:
    Constant Field Values
  - NUM_ROUTE_SEGMENTS
```
public static final int NUM_ROUTE_SEGMENTS
```
    number of segments for RouteWidgets
    
    See Also:
    Constant Field Values
  - CONE_RADIUS_FACTOR
```
public static final float CONE_RADIUS_FACTOR
```
    Joint ConeWidget dimensions relative to LinkageNode.widgetLength.
    
    See Also:
    Constant Field Values
  - CONE_HEIGHT_FACTOR
```
public static final float CONE_HEIGHT_FACTOR
```
    Joint ConeWidget dimensions relative to LinkageNode.widgetLength.
    
    See Also:
    Constant Field Values
  - NUM_CONE_SECTORS
```
public static final int NUM_CONE_SECTORS
```
    number of sectors for ConeWidgets
    
    See Also:
    Constant Field Values
  - DEGENERATE_ROUTE_TOL
```
public static final double DEGENERATE_ROUTE_TOL
```
    tolerance for checking route widget degeneracy
    
    See Also:
    Constant Field Values
  - BROKEN_TOL
```
public static final double BROKEN_TOL
```
    tolerance for isBroken()
    
    See Also:
    Constant Field Values
  - JW_COLOR_SCHEME
```
public static final vona.color.ColorScheme JW_COLOR_SCHEME
```
    Color scheme for Joint Widgets.
  - TREE_ROUTE_COLOR_SCHEME
```
public static final vona.color.ColorScheme TREE_ROUTE_COLOR_SCHEME
```
    Color scheme for tree joint RouteWidgets.
  - CLOSURE_ROUTE_COLOR_SCHEME
```
public static final vona.color.ColorScheme CLOSURE_ROUTE_COLOR_SCHEME
```
    Color scheme for closure joint RouteWidgets.
  - MOBILITY_ERROR_ROUTE_COLOR
```
public static final java.awt.Color MOBILITY_ERROR_ROUTE_COLOR
```
    color of mobility routes for broken closures
  - JW_AXES
```
public static final java.lang.String JW_AXES
```
    WP_JOINT values
    
    See Also:
    Constant Field Values
  - JW_LABEL
```
public static final java.lang.String JW_LABEL
```
    WP_JOINT values
    
    See Also:
    Constant Field Values
  - JW_ROUTE
```
public static final java.lang.String JW_ROUTE
```
    WP_JOINT values
    
    See Also:
    Constant Field Values
  - JW_ROUTE_CONE
```
public static final java.lang.String JW_ROUTE_CONE
```
    WP_JOINT values
    
    See Also:
    Constant Field Values
  - JW_MOBILITY_SURFACE
```
public static final java.lang.String JW_MOBILITY_SURFACE
```
    WP_JOINT values
    
    See Also:
    Constant Field Values
  - JW_SLIDER_SURFACE
```
public static final java.lang.String JW_SLIDER_SURFACE
```
    WP_JOINT values
    
    See Also:
    Constant Field Values
  - JW_MOBILITY_SLIDER
```
public static final java.lang.String JW_MOBILITY_SLIDER
```
    WP_JOINT values
    
    See Also:
    Constant Field Values
  - WN_CHILD_MOBILITY_AXES
```
public static final java.lang.String WN_CHILD_MOBILITY_AXES
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - WN_PARENT_MOBILITY_AXES
```
public static final java.lang.String WN_PARENT_MOBILITY_AXES
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - WN_C_TO_M_ROUTE
```
public static final java.lang.String WN_C_TO_M_ROUTE
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - WN_MOBILITY_ROUTE
```
public static final java.lang.String WN_MOBILITY_ROUTE
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - WN_M_TO_P_ROUTE
```
public static final java.lang.String WN_M_TO_P_ROUTE
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - WN_ROUTE_CONE_SUFFIX
```
public static final java.lang.String WN_ROUTE_CONE_SUFFIX
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - WN_JOINT_LABEL
```
public static final java.lang.String WN_JOINT_LABEL
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - WN_JOINT_CYLINDER
```
public static final java.lang.String WN_JOINT_CYLINDER
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - WN_JOINT_SECTOR
```
public static final java.lang.String WN_JOINT_SECTOR
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - WN_JOINT_SECTOR_ENDS
```
public static final java.lang.String WN_JOINT_SECTOR_ENDS
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - WN_JOINT_SEGMENT
```
public static final java.lang.String WN_JOINT_SEGMENT
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - WN_JOINT_PRISM
```
public static final java.lang.String WN_JOINT_PRISM
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - WN_JOINT_PRISM_ENDS
```
public static final java.lang.String WN_JOINT_PRISM_ENDS
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - WN_JOINT_SQUARE
```
public static final java.lang.String WN_JOINT_SQUARE
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - WN_JOINT_CIRCLE
```
public static final java.lang.String WN_JOINT_CIRCLE
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - WN_JOINT_SPHERE
```
public static final java.lang.String WN_JOINT_SPHERE
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - WN_JOINT_RECTANGLE
```
public static final java.lang.String WN_JOINT_RECTANGLE
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - WN_JOINT_RECTANGLE_Y_EDGES
```
public static final java.lang.String WN_JOINT_RECTANGLE_Y_EDGES
```
    Joint Widget names
    
    See Also:
    Constant Field Values
  - tempV3
```
protected final float[][] tempV3
```
    temp storage
  - tempV3D
```
protected final double[] tempV3D
```
    temp storage
  - parentLink
```
protected Link parentLink
```
    The Link leading to this joint, or null if dangling.
  - childLink
```
protected Link childLink
```
    The immediate descendant of this joint, or null if dangling.
  - childLinks
```
protected final java.util.List<Link> childLinks
```
    Contains childLink (for getChildren()), empty if dangling.
  - unmodifiableChildLinks
```
protected final java.util.List<Link> unmodifiableChildLinks
```
    unmodifiable view of childLinks
  - childToMobilityRX
```
protected final vona.math.RX childToMobilityRX
```
    Sub transform taking the child frame to the child mobility frame.
    
    See Linkage class header doc for details.
  - childSubFrame
```
protected java.lang.String childSubFrame
```
    Subframe in child link corresponding to childToMobilityRX, if any.
  - mobilityRX
```
protected final vona.math.RX mobilityRX
```
    Sub transform taking the child mobility frame to the parent mobility frame, or vice-versa if mobilityInverted.
    
    See Linkage class header doc for details.
  - mobilityRXClamped
```
protected final vona.math.RX mobilityRXClamped
```
    Mirror of mobilityRX, but always clamped to limits.
  - mobilityToParentRX
```
protected final vona.math.RX mobilityToParentRX
```
    Sub transform taking the parent mobility frame to the parent frame.
    
    See Linkage class header doc for details.
  - parentSubFrame
```
protected java.lang.String parentSubFrame
```
    Subframe in parent link corresponding to mobilityToParentRX, if any.
  - jointRX
```
protected final vona.math.RX jointRX
```
    Total transform taking the child frame to the parent frame.
    
    See Linkage class header doc for details.
  - targetRX
```
protected final vona.math.RX targetRX
```
    Current mobilityRX target.
    
    Un-set components track mobilityRX.
  - postureRX
```
protected final vona.math.RX postureRX
```
    Current mobilityRX posture.
    
    Un-set components track mobilityRX.
  - invariantRX
```
protected final vona.math.RX invariantRX
```
    Current mobilityRX invariant goal.
    
    DoF track mobilityRX, DoI match Joint.Type.invariant.
  - lockRX
```
protected final vona.math.RX lockRX
```
    Current mobilityRX lock goal.
    
    Frozen at mobilityRX at the time the Joint is locked. If not locked, tracks mobilityRX.
  - tempRX
```
protected final vona.math.RX tempRX
```
    a temp transform
  - RX_INVARIANT
```
public static final int RX_INVARIANT
```
    Sub-transform identifiers, goals must come first to support indexing in setGoalComponents.
    
    RX_TARGET and RX_POSTURE are soft goals; RX_INVARIANT and RX_LOCK are hard goals.
    
    Ordered so that all mobility space transforms are leq RX_MOBILITY.
    
    See Also:
    Constant Field Values
  - RX_LOCK
```
public static final int RX_LOCK
```
    Sub-transform identifiers, goals must come first to support indexing in setGoalComponents.
    
    RX_TARGET and RX_POSTURE are soft goals; RX_INVARIANT and RX_LOCK are hard goals.
    
    Ordered so that all mobility space transforms are leq RX_MOBILITY.
    
    See Also:
    Constant Field Values
  - RX_TARGET
```
public static final int RX_TARGET
```
    Sub-transform identifiers, goals must come first to support indexing in setGoalComponents.
    
    RX_TARGET and RX_POSTURE are soft goals; RX_INVARIANT and RX_LOCK are hard goals.
    
    Ordered so that all mobility space transforms are leq RX_MOBILITY.
    
    See Also:
    Constant Field Values
  - RX_POSTURE
```
public static final int RX_POSTURE
```
    Sub-transform identifiers, goals must come first to support indexing in setGoalComponents.
    
    RX_TARGET and RX_POSTURE are soft goals; RX_INVARIANT and RX_LOCK are hard goals.
    
    Ordered so that all mobility space transforms are leq RX_MOBILITY.
    
    See Also:
    Constant Field Values
  - RX_MOBILITY
```
public static final int RX_MOBILITY
```
    Sub-transform identifiers, goals must come first to support indexing in setGoalComponents.
    
    RX_TARGET and RX_POSTURE are soft goals; RX_INVARIANT and RX_LOCK are hard goals.
    
    Ordered so that all mobility space transforms are leq RX_MOBILITY.
    
    See Also:
    Constant Field Values
  - RX_CHILD_TO_MOBILITY
```
public static final int RX_CHILD_TO_MOBILITY
```
    Sub-transform identifiers, goals must come first to support indexing in setGoalComponents.
    
    RX_TARGET and RX_POSTURE are soft goals; RX_INVARIANT and RX_LOCK are hard goals.
    
    Ordered so that all mobility space transforms are leq RX_MOBILITY.
    
    See Also:
    Constant Field Values
  - RX_MOBILITY_TO_PARENT
```
public static final int RX_MOBILITY_TO_PARENT
```
    Sub-transform identifiers, goals must come first to support indexing in setGoalComponents.
    
    RX_TARGET and RX_POSTURE are soft goals; RX_INVARIANT and RX_LOCK are hard goals.
    
    Ordered so that all mobility space transforms are leq RX_MOBILITY.
    
    See Also:
    Constant Field Values
  - PG_STIFFNESS
```
public static final int PG_STIFFNESS
```
    Non-transform goal identifiers.
    
    See Also:
    Constant Field Values
  - PG_GRAVITY
```
public static final int PG_GRAVITY
```
    Non-transform goal identifiers.
    
    See Also:
    Constant Field Values
  - PG_POTENTIAL
```
public static final int PG_POTENTIAL
```
    Non-transform goal identifiers.
    
    See Also:
    Constant Field Values
  - G_LIMIT
```
public static final int G_LIMIT
```
    Non-transform goal identifiers.
    
    See Also:
    Constant Field Values
  - LIMIT_PENALTY_DEGREE
```
public static final int LIMIT_PENALTY_DEGREE
```
    Polynomial degree of the limit penalty function.
    
    Must be even and positive.
    
    See Also:
    Constant Field Values
  - NUM_SUBTRANSFORMS
```
public static final int NUM_SUBTRANSFORMS
```
    number of subtransforms
    
    See Also:
    Constant Field Values
  - NUM_GOAL_SUBTRANSFORMS
```
public static final int NUM_GOAL_SUBTRANSFORMS
```
    number of subtransforms
    
    See Also:
    Constant Field Values
  - NUM_HARD_GOAL_SUBTRANSFORMS
```
public static final int NUM_HARD_GOAL_SUBTRANSFORMS
```
    number of subtransforms
    
    See Also:
    Constant Field Values
  - NUM_SOFT_GOAL_SUBTRANSFORMS
```
public static final int NUM_SOFT_GOAL_SUBTRANSFORMS
```
    number of subtransforms
    
    See Also:
    Constant Field Values
  - NUM_CHAIN_SUBTRANSFORMS
```
public static final int NUM_CHAIN_SUBTRANSFORMS
```
    number of subtransforms
    
    See Also:
    Constant Field Values
  - subRX
```
protected final vona.math.RX[] subRX
```
    the various sub-transforms, indexed by identifier
  - SUB_RX_NAME
```
public static final java.lang.String[] SUB_RX_NAME
```
    names of the sub-transforms
  - ALL_TXEM_INDICES
```
public static final int[] ALL_TXEM_INDICES
```
    vector of all six TXEM indices
  - setGoalComponents
```
protected final int[][] setGoalComponents
```
    cached quantity
  - setTranslationGoalComponents
```
protected final int[][] setTranslationGoalComponents
```
    cached quantity
  - setRotationGoalComponents
```
protected final int[][] setRotationGoalComponents
```
    cached quantity
  - setLimitComponents
```
protected int[] setLimitComponents
```
    cached quantity: limited DoF indices only (no DoI)
  - setTranslationLimitComponents
```
protected int[] setTranslationLimitComponents
```
    cached quantity: limited DoF indices only (no DoI)
  - setRotationLimitComponents
```
protected int[] setRotationLimitComponents
```
    cached quantity: limited DoF indices only (no DoI)
  - unsetGoalComponents
```
protected final int[][] unsetGoalComponents
```
    cached quantity
  - unsetLimitComponents
```
protected int[] unsetLimitComponents
```
    cached quantity: unlimited DoF indices only (no DoI)
  - locked
```
protected boolean locked
```
    whether this Joint is currently locked
  - mobilityInverted
```
protected boolean mobilityInverted
```
    whether this Joint's mobility space is currently inverted
  - positioningTransformsLocked
```
protected boolean positioningTransformsLocked
```
    Whether RX_CHILD_TO_MOBILITY and RX_MOBILITY_TO_PARENT are currently locked.
  - support
```
public final java.util.List<Joint> support
```
    Joints associated to this Joint in a Solver.
    
    This is populated by Controller.analyze() according to whether this Joint isClosureJoint().
    
    The support of a a chain closure Joint cj is its kinematic cycle, not including cj itself. They cycle is stored in order, starting at the Link.parentJoint of childLink, continuing down to one of the Link.childJoints of branchLink, then up through another of the Link.childJoints of branchLink, and ending at the Link.parentJoint of parentLink. Locked tree Joints are not included in the cycle.
    
    For a tree Joint tj, support contains the list of chain closure Joints whose supports contain tj.
    
    Note that support will be empty for chain closure Joints whose cycle contains no other unlocked Joints (including closure Joints whose parentLink and childLink are the same), and for tree Joints that are not in the support of any chain closure Joint.
  - solver
```
public Solver solver
```
    the Solver assigned by Controller.analyze(), iff any
  - branchLink
```
public Link branchLink
```
    For a chain closure joint, Controller.analyze() sets this to the least common ancestor of the model tree branches containing parentLink and childLink. Null for tree joints.
  - lastSupportIndexBeforeBranch
```
public int lastSupportIndexBeforeBranch
```
    For a chain closure joint, Controller.analyze() sets this to the index of the last actuator in support before branchLink. -1 if all supporting actuators are after branchLink, or if there are no supporting actuators (there is always a branchLink).
  - jacobianStartColumn
```
public int jacobianStartColumn
```
    Start index of the span of Jacobian columns corresponding to this Joint in solver, or -1 if none.
  - jacobianDoIStartRow
```
public int jacobianDoIStartRow
```
    Start indices of the spans of Jacobian rows corresponding to this Joint in solver, or -1 if none.
  - jacobianLimitStartRow
```
public int jacobianLimitStartRow
```
    Start indices of the spans of Jacobian rows corresponding to this Joint in solver, or -1 if none.
  - jacobianDoFStartRow
```
public int jacobianDoFStartRow
```
    Start indices of the spans of Jacobian rows corresponding to this Joint in solver, or -1 if none.
  - softGoalWeight
```
public double softGoalWeight
```
    Solve weight of the highest priority soft goal of this Joint in solver.
    
    See getHighestPrioritySoftGoal().
  - softGoalPriority
```
public float softGoalPriority
```
    Solve priority of the highest priority soft goal of this Joint in solver.
    
    See getHighestPrioritySoftGoal().
    
    This sets up a partial order among all soft goals of the same kind in solver, and that implies softGoalSolveLevel. Higher priority soft goals will be met first relative to other joints with the same kind of soft goal (target or posture).
  - softGoalSolveLevel
```
public int softGoalSolveLevel
```
    Solve level of the highest priority soft goal, if any, of this Joint in solver.
    
    See softGoalPriority.
  - parentMobilityCMT
```
protected final vona.math.RX parentMobilityCMT
```
    cached quantity
  - childMobilityCMT
```
protected final vona.math.RX childMobilityCMT
```
    cached quantity
  - parentMobilityCMTDirty
```
protected boolean parentMobilityCMTDirty
```
    dirty flag for indicated quantity
  - childMobilityCMTDirty
```
protected boolean childMobilityCMTDirty
```
    dirty flag for indicated quantity
  - parentMobilityCMTRotMatrix
```
protected final double[] parentMobilityCMTRotMatrix
```
    cached quantity
  - childMobilityCMTRotMatrix
```
protected final double[] childMobilityCMTRotMatrix
```
    cached quantity
  - mobilityRotMatrix
```
protected final double[] mobilityRotMatrix
```
    cached quantity
  - parentMobilityCMTRotMatrixDirty
```
protected boolean parentMobilityCMTRotMatrixDirty
```
    dirty flag for indicated quantity
  - childMobilityCMTRotMatrixDirty
```
protected boolean childMobilityCMTRotMatrixDirty
```
    dirty flag for indicated quantity
  - mobilityRotMatrixDirty
```
protected boolean mobilityRotMatrixDirty
```
    dirty flag for indicated quantity
  - parentMobilityCMTQuaternion
```
protected final double[] parentMobilityCMTQuaternion
```
    cached quantity
  - childMobilityCMTQuaternion
```
protected final double[] childMobilityCMTQuaternion
```
    cached quantity
  - mobilityQuaternion
```
protected final double[] mobilityQuaternion
```
    cached quantity
  - parentMobilityCMTQuaternionDirty
```
protected boolean parentMobilityCMTQuaternionDirty
```
    dirty flag for indicated quantity
  - childMobilityCMTQuaternionDirty
```
protected boolean childMobilityCMTQuaternionDirty
```
    dirty flag for indicated quantity
  - mobilityQuaternionDirty
```
protected boolean mobilityQuaternionDirty
```
    dirty flag for indicated quantity
  - mobilitydQdEM
```
protected final double[][] mobilitydQdEM
```
    cached quantity
  - mobilitydEMdQ
```
protected final double[][] mobilitydEMdQ
```
    cached quantity
  - mobilitydRdQ
```
protected final double[][] mobilitydRdQ
```
    cached quantity
  - mobilitydRdEM
```
protected final double[][] mobilitydRdEM
```
    cached quantity
  - mobilitydQdEMDirty
```
protected boolean mobilitydQdEMDirty
```
    dirty flag for indicated quantity
  - mobilitydEMdQDirty
```
protected boolean mobilitydEMdQDirty
```
    dirty flag for indicated quantity
  - mobilitydRdQDirty
```
protected boolean mobilitydRdQDirty
```
    dirty flag for indicated quantity
  - mobilitydRdEMDirty
```
protected boolean mobilitydRdEMDirty
```
    dirty flag for indicated quantity
  - mobilityRXInverse
```
protected vona.math.RX mobilityRXInverse
```
    cached quantity
  - mobilityRXClampedInverse
```
protected vona.math.RX mobilityRXClampedInverse
```
    cached quantity
  - mobilityRXInverseDirty
```
protected boolean mobilityRXInverseDirty
```
    dirty flag for indicated quantity
  - mobilityRXClampedInverseDirty
```
protected boolean mobilityRXClampedInverseDirty
```
    dirty flag for indicated quantity
  - singleMobilityDoF
```
protected double singleMobilityDoF
```
    cached quantity
  - singleMobilityDoFDirty
```
protected boolean singleMobilityDoFDirty
```
    dirty flag for indicated quantity
  - LOWER
```
public static final int LOWER
```
    limit and limitSet categories
    
    See Also:
    Constant Field Values
  - UPPER
```
public static final int UPPER
```
    limit and limitSet categories
    
    See Also:
    Constant Field Values
  - limit
```
protected final double[][] limit
```
    LOWER and UPPER limits for each DoF iff limitSet, NaN for DoF with unset limits, or the invariant value for DoI.
    
    Stored as packed translation and exponential map parameters.
  - limitSet
```
protected final boolean[] limitSet
```
    Whether we currently have a limit for each TXEM parameter.
    
    This is always true for DoI, and it's true for each DoF that has set limits.
  - translationDoFLimited
```
protected boolean translationDoFLimited
```
    Whether the indicated motion DoF space has any limits currently set.
  - rotationDoFLimited
```
protected boolean rotationDoFLimited
```
    Whether the indicated motion DoF space has any limits currently set.
  - potentialEnabled
```
protected boolean potentialEnabled
```
    Gating enable for any potential goal.
    
    Default true.
  - stiffness
```
protected double stiffness
```
    stiffness of this joint or NaN if unset
  - stiffnessRest
```
protected double stiffnessRest
```
    stiffness rest pose of this joint, default 0
  - TYPES
```
public static final Joint.Type[] TYPES
```
    set of all Joint.Types, do not modify
  - NUM_TYPES
```
public static final int NUM_TYPES
```
    number of different Joint.Types
  - type
```
protected Joint.Type type
```
    the current Joint Joint.Type
  - RESIDUAL_TYPES
```
public static final Joint.ResidualType[] RESIDUAL_TYPES
```
    set of all Joint.ResidualTypes, do not modify
  - NUM_RESIDUAL_TYPES
```
public static final int NUM_RESIDUAL_TYPES
```
    number of different Joint.ResidualTypes
- Constructor Detail
  - Joint
```
public Joint(Linkage linkage,
     java.lang.String name,
     Joint.Type type,
     Link parentLink,
     java.lang.String parentSubFrame,
     Link childLink,
     java.lang.String childSubFrame)
```
    Makes a new chain closure joint and adds it to linkage.
    
    Parameters:
    linkage - the Linkage to contain this joint, not null
    name - the initial name of this Joint or null to auto-name
    type - the initial Joint.Type of this Joint or null to default to Joint.Type.GENERAL
    parentLink - the initial parent Link, or null for none
    parentSubFrame - the initial parent subframe, or null for none
    childLink - the initial child Link, or null for none
    childSubFrame - the initial child subframe, or null for none
    
    Throws:
    
    java.lang.IllegalArgumentException - if name is non-null and fails checkName(java.lang.String), in this case the new Joint is not added to linkage
  - Joint
```
public Joint(Linkage linkage,
     java.lang.String name,
     Joint.Type type,
     LinkageNode.SubFrame parent,
     LinkageNode.SubFrame child)
```
    Covers Joint(Linkage, String, Type, Link, String, Link, String).
  - Joint
```
public Joint(Linkage linkage,
     java.lang.String name,
     Joint.Type type,
     Link parentLink,
     Link childLink)
```
    Covers Joint(Linkage, String, Type, Link, String, Link, String), does not attach to subframes.
  - Joint
```
public Joint(Linkage linkage,
     Joint.Type type,
     Link parentLink,
     java.lang.String parentSubFrame,
     Link childLink,
     java.lang.String childSubFrame)
```
    Covers Joint(Linkage, String, Type, Link, String, Link, String), auto-named.
  - Joint
```
public Joint(Linkage linkage,
     Joint.Type type,
     LinkageNode.SubFrame parent,
     LinkageNode.SubFrame child)
```
    Covers Joint(Linkage, Type, Link, String, Link, String).
  - Joint
```
public Joint(Linkage linkage,
     Joint.Type type,
     Link parentLink,
     Link childLink)
```
    Covers Joint(Linkage, String, Type, Link, Link), auto-named.
  - Joint
```
public Joint(Linkage linkage,
     java.lang.String name,
     Joint.Type type)
```
    Covers Joint(Linkage, String, Type, Link, Link), initially disconnected.
  - Joint
```
public Joint(Linkage linkage,
     java.lang.String name)
```
    Covers Joint(Linkage, String, Type, Link, Link), initially disconnected and Joint.Type.GENERAL.
  - Joint
```
public Joint(Linkage linkage,
     Joint.Type type)
```
    Covers Joint(Linkage, String, Type, Link, Link), initially disconnected, auto-named.
  - Joint
```
public Joint(Linkage linkage)
```
    Covers Joint(Linkage, String, Type, Link, Link), initially disconnected, Joint.Type.GENERAL, and auto-named.
  - Joint
```
public Joint(Linkage linkage,
     java.lang.String name,
     Link parentLink,
     java.lang.String parentSubFrame,
     Link childLink,
     java.lang.String childSubFrame)
```
    Covers Joint(Linkage, String, Type, Link, String, Link, String), initially Joint.Type.GENERAL.
  - Joint
```
public Joint(Linkage linkage,
     java.lang.String name,
     LinkageNode.SubFrame parent,
     LinkageNode.SubFrame child)
```
    Covers Joint(Linkage, String, Link, String, Link, String).
  - Joint
```
public Joint(Linkage linkage,
     java.lang.String name,
     Link parentLink,
     Link childLink)
```
    Covers Joint(Linkage, String, Type, Link, Link), initially Joint.Type.GENERAL.
  - Joint
```
public Joint(Linkage linkage,
     Link parentLink,
     java.lang.String parentSubFrame,
     Link childLink,
     java.lang.String childSubFrame)
```
    Covers Joint(Linkage, String, Type, Link, String, Link, String), initially Joint.Type.GENERAL and auto named.
  - Joint
```
public Joint(Linkage linkage,
     LinkageNode.SubFrame parent,
     LinkageNode.SubFrame child)
```
    Covers Joint(Linkage, Link, String, Link, String).
  - Joint
```
public Joint(Linkage linkage,
     Link parentLink,
     Link childLink)
```
    Covers Joint(Linkage, String, Type, Link, Link), initially Joint.Type.GENERAL and auto named.
- Method Detail
  - getParentLink
```
public Link getParentLink()
```
    get the current parentLink, null if none
  - getChildLink
```
public Link getChildLink()
```
    get the current childLink, null if none
  - getAttachmentName
```
public static java.lang.String getAttachmentName(Link link,
                                 java.lang.String subFrame)
```
    common impl of getParentName() and getChildName()
  - getParentName
```
public java.lang.String getParentName()
```
    Get the name of the current attached child and child subframe, if any, else null.
  - getChildName
```
public java.lang.String getChildName()
```
    Get the name of the current attached child and child subframe, if any, else null.
  - getParentSubFrame
```
public java.lang.String getParentSubFrame()
```
    get the current parentSubFrame, null if none
  - getChildSubFrame
```
public java.lang.String getChildSubFrame()
```
    get the current childSubFrame, null if none
  - setName
```
public java.lang.String setName(java.lang.String name)
```
    Set the name of this Joint.
    
    Has no effect if the new name equals the old.
    
    Specified by:
    
    setName in class LinkageNode
    
    Parameters:
    name - new name or null to auto-name
    
    Returns:
    the old name
    
    Throws:
    
    java.lang.IllegalArgumentException - if name fails checkName(java.lang.String), in this case the name is not changed
  - checkName
```
public boolean checkName(java.lang.String name)
```
    Extends superclass impl to verify name is unique in parentLink, if any.
    
    Overrides:
    
    checkName in class LinkageNode
  - getParent
```
public LinkageNode getParent()
```
    returns parentLink
    
    Specified by:
    
    getParent in class LinkageNode
  - getChild
```
public LinkageNode getChild(java.lang.String name)
```
    returns childLink iff name matches
    
    Specified by:
    
    getChild in class LinkageNode
  - getChildren
```
public java.util.Collection<? extends LinkageNode> getChildren()
```
    returns an unmodifiable view of childLinks
    
    Specified by:
    
    getChildren in class LinkageNode
  - hasChildren
```
public boolean hasChildren()
```
    check whether this node has any children
    This impl checks if childLink is not null.
    
    Overrides:
    
    hasChildren in class LinkageNode
  - isTreeLeaf
```
public boolean isTreeLeaf()
```
    Check if this is a leaf in the model tree.
    
    Default impl checks if not LinkageNode.hasChildren() .
    
    This impl checks if childLink is null or isClosureJoint().
    
    Overrides:
    
    isTreeLeaf in class LinkageNode
  - updateCMTs
```
public void updateCMTs()
```
    Update this node's LinkageNode.cmt based on its parent's LinkageNode.cmt.
    
    Implementations may also compute and cache other CMT-related state in this call, such as CMTs for sub-frames.
    
    For details on the semantics of CMTs see the Linkage class header doc.
    
    Specified by:
    
    updateCMTs in class LinkageNode
  - getParentMobilityCMTRef
```
public vona.math.RX getParentMobilityCMTRef()
```
    get a ref to the indicated cached quantity, recomputing if dirty
  - getChildMobilityCMTRef
```
public vona.math.RX getChildMobilityCMTRef()
```
    get a ref to the indicated cached quantity, recomputing if dirty
  - getParentMobilityCMTRotMatrixRef
```
public double[] getParentMobilityCMTRotMatrixRef()
```
    get a ref to the indicated cached quantity, recomputing if dirty
  - getChildMobilityCMTRotMatrixRef
```
public double[] getChildMobilityCMTRotMatrixRef()
```
    get a ref to the indicated cached quantity, recomputing if dirty
  - getParentMobilityCMTQuaternionRef
```
public double[] getParentMobilityCMTQuaternionRef()
```
    get a ref to the indicated cached quantity, recomputing if dirty
  - getChildMobilityCMTQuaternionRef
```
public double[] getChildMobilityCMTQuaternionRef()
```
    get a ref to the indicated cached quantity, recomputing if dirty
  - getMobilityRotMatrixRef
```
public double[] getMobilityRotMatrixRef()
```
    get a ref to the indicated cached quantity, recomputing if dirty
  - getMobilityQuaternionRef
```
public double[] getMobilityQuaternionRef()
```
    get a ref to the indicated cached quantity, recomputing if dirty
  - getMobilitydQdEMRef
```
public double[][] getMobilitydQdEMRef()
```
    get a ref to the indicated cached quantity, recomputing if dirty
  - getMobilitydEMdQRef
```
public double[][] getMobilitydEMdQRef()
```
    get a ref to the indicated cached quantity, recomputing if dirty
  - getMobilitydRdQRef
```
public double[][] getMobilitydRdQRef()
```
    get a ref to the indicated cached quantity, recomputing if dirty
  - getMobilitydRdEMRef
```
public double[][] getMobilitydRdEMRef()
```
    get a ref to the indicated cached quantity, recomputing if dirty
  - getMobilityRXClampedInverseRef
```
public vona.math.RX getMobilityRXClampedInverseRef()
```
    get a ref to the indicated cached quantity, recomputing if dirty
  - getMobilityRXInverseRef
```
public vona.math.RX getMobilityRXInverseRef()
```
    get a ref to the indicated cached quantity, recomputing if dirty
  - getSingleMobilityDoF
```
public double getSingleMobilityDoF()
```
    get a ref to the indicated cached quantity, recomputing if dirty
  - remove
```
public void remove()
```
    Remove this node from the Linkage tree.
    
    All adjacent Joint endpoints are dangled.
    
    Once a node has been removed it cannot be re-added.
    
    If this is a connected tree joint, it is first converted to a chain closure (makeClosureJoint()). Then the child and parent Links are detached, in that order.
    
    Specified by:
    
    remove in class LinkageNode
  - merge
```
public Link merge(boolean reparentUserJointWidgets,
         boolean reparentUserLinkWidgets)
```
    remove() this Joint and its child Link from the model, re-attaching joints that were attached to the child Link to our parent Link.
    
    Our own user widgets, as well as those of our child Link, are also optionally re-parented to our parent Link.
    
    If this Joint is dangling then the effect is the same as first (optionally) migrating its user widgets to the adjacent Link and then calling remove().
    
    If this Joint is connected then it is first made a tree joint (see makeTreeJoint()), then the Joints attached to the child Link are re-attached to the parent Link without changing the absolute pose of their mobility frames, the widgets are optionally migrated, and then both this Joint and its child Link are removed from the model.
    
    See also Link.split().
    
    Returns:
    the Link to which things were merged, which will be our parent Link if currently connected, otherwise it will be the attached Link, if any, else null
    
    Throws:
    
    java.lang.IllegalStateException - if isCrossing()
  - merge
```
public Link merge(boolean reparentWidgets)
```
    Covers merge(boolean, boolean), reparents both Joint and Link user widgets or not.
  - merge
```
public Link merge()
```
    Covers merge(boolean, boolean), reparents both Joint and Link user widgets.
  - setParentLink
```
public Link setParentLink(Link parentLink,
                 java.lang.String parentSubFrame,
                 boolean holdAbsolutePose)
```
    Mutate the parentLink.
    
    Does nothing if the passed link is the same as the current parentLink.
    
    If LinkageNode.isAutoNamed(), and the current Joint name is not unique in the new parent, a new unique name will be automatically assigned.
    
    If parentLink is in the enclosing Linkage and this was a connected tree joint, then childLink becomes the new ground link of this sublinkage (if it is not already the ground link). If the old ground link was connected to the superlinkage by a tree joint t other than its RootJoint, t is made a chain closure, enforcing the invariant that there is always exactly one outcrossing tree joint from every sublinkage.
    
    Specifying non-null parentSubFrame indicates attachment to a link subframe. In this case the mobilityToParentRX transform is set from the corresponding sub-frame transform. Subsequent mutations to either are propagated to the other. Subframe attachment is currently only implmented for user subframes (see Link.addUserSubFrame(java.lang.String, vona.math.RX)).
    
    Parameters:
    parentLink - the new parentLink or null to dangle
    parentSubFrame - the new subframe to attach to in parentLink, or null to attach directly to link frame
    holdAbsolutePose - whether to request holding the current SF_PARENT_MOBILITY absolute pose. Otherwise SF_PARENT_MOBILITY will have the same relative pose to its new parent (if any) as it did to its old parent. The request is not honored if not positioningTransformsMutable().
    
    Returns:
    the old parentLink
    
    Throws:
    
    java.lang.IllegalArgumentException - if parentLink is not live
    
    java.lang.IllegalArgumentException - if parentSubFrame is not null and not a current user subframe in parentLink
    
    java.lang.IllegalStateException - if there is a current child link and Link.isConnectableToJoint(java.lang.String, msim.model.Joint, msim.model.Link) fails for the new candidate parent
    
    java.lang.IllegalStateException - if there is not a current child link and Link.isConnectableToJointType(java.lang.String, msim.model.Joint.Type) fails for the new candidate parent
    
    java.lang.IllegalArgumentException - if parentLink is not null and aliases existing childLink
    
    java.lang.IllegalArgumentException - if parentLink is neither in LinkageNode.linkage nor the enclosing Linkage
    
    java.lang.IllegalArgumentException - if parentLink is in the Linkage enclosing LinkageNode.linkage and so is the existing childLink
    
    java.lang.IllegalStateException - if not auto-named and parentLink contains a different Joint with the same name as this Joint
    
    java.lang.IllegalArgumentException - if parentLink is null but isConnected() and isTreeJoint()
  - setParentLink
```
public Link setParentLink(LinkageNode.SubFrame parent,
                 boolean holdAbsolutePose)
```
    Covers setParentLink(Link, String, boolean).
  - setParentLink
```
public Link setParentLink(Link parentLink,
                 java.lang.String parentSubFrame)
```
    setParentLink(Link, String, boolean), does not request holding absolute pose.
  - setParentLink
```
public Link setParentLink(LinkageNode.SubFrame parent)
```
    Covers setParentLink(Link, String).
  - setParentLink
```
public Link setParentLink(Link parentLink,
                 boolean holdAbsolutePose)
```
    setParentLink(Link, String, boolean), does not attach to subframe.
  - setParentLink
```
public Link setParentLink(Link parentLink)
```
    setParentLink(Link, boolean), does not request holding absolute pose.
  - detachParentLink
```
public Link detachParentLink()
```
    setParentLink(Link) null
  - setChildLink
```
public Link setChildLink(Link childLink,
                java.lang.String childSubFrame,
                boolean holdAbsolutePose)
```
    Mutate the childLink.
    
    Does nothing if the passed link is the same as the current childLink.
    
    Specifying non-null childSubFrame indicates attachment to a link subframe. In this case the childToMobilityRX transform is set from the inverse of the corresponding sub-frame transform. Subsequent mutations to either are propagated to the other. Subframe attachment is currently only implmented for user subframes (see Link.addUserSubFrame(java.lang.String, vona.math.RX)).
    
    Parameters:
    childLink - the new childLink or null to dangle
    childSubFrame - the new subframe to attach to in childLink, or null to attach directly to link frame
    holdAbsolutePose - whether to request holding childLink's existing absolute pose. Otherwise childLink will be moved to have the relative pose defined by the current state of this Joint to its parentLink, if any.
    
    Returns:
    the old childLink
    
    Throws:
    
    java.lang.IllegalArgumentException - if childLink is not live
    
    java.lang.IllegalArgumentException - if childSubFrame is not null and not a current user subframe in childLink
    
    java.lang.IllegalStateException - if there is a current parent link and Link.isConnectableToJoint(java.lang.String, msim.model.Joint, msim.model.Link) fails for the new candidate child
    
    java.lang.IllegalStateException - if there is not a current parent link and Link.isConnectableToJointType(java.lang.String, msim.model.Joint.Type) fails for the new candidate child
    
    java.lang.IllegalArgumentException - if parentLink is not null and
    
    java.lang.IllegalArgumentException - if childLink is not null and aliases existing parentLink
    
    java.lang.IllegalArgumentException - if childLink is neither in LinkageNode.linkage nor the enclosing Linkage
    
    java.lang.IllegalArgumentException - if childLink is in the Linkage enclosing LinkageNode.linkage and so is the existing parentLink
    
    java.lang.IllegalArgumentException - if isTreeJoint(), childLink is in the Linkage enclosing LinkageNode.linkage, and the Linkage.disposition of LinkageNode.linkage is Linkage.Disposition.DRIVEN
    
    java.lang.IllegalArgumentException - if isTreeJoint(), and childLink is the ground link in the Linkage enclosing LinkageNode.linkage
  - setChildLink
```
public Link setChildLink(LinkageNode.SubFrame child,
                boolean holdAbsolutePose)
```
    Covers setChildLink(Link, String, boolean).
  - setChildLink
```
public Link setChildLink(Link childLink,
                java.lang.String childSubFrame)
```
    setChildLink(Link, String, boolean), does not request holding absolute pose.
  - setChildLink
```
public Link setChildLink(LinkageNode.SubFrame child)
```
    Covers setChildLink(Link, String).
  - setChildLink
```
public Link setChildLink(Link childLink,
                boolean holdAbsolutePose)
```
    setChildLink(Link, String, boolean), does not attach to subframe.
  - setChildLink
```
public Link setChildLink(Link childLink)
```
    setChildLink(Link, boolean), does not request holding absolute pose.
  - detachChildLink
```
public Link detachChildLink()
```
    setChildLink(Link) null
  - isConnected
```
public boolean isConnected()
```
    check if both parentLink and childLink are set
  - isClosureJoint
```
public boolean isClosureJoint()
```
    Checks not isTreeJoint(), i.e. this Joint is a Closure if either childLink is null or the Link.parentJoint of childLink is not this Joint.
  - isBroken
```
public boolean isBroken()
```
    check if this breaks DoI or DoF limits (using BROKEN_TOL)
  - isTreeJoint
```
public boolean isTreeJoint()
```
    Checks if we have a childLink and its Link.parentJoint is this Joint.
  - isIncrossing
```
public boolean isIncrossing()
```
    Check if childLink is not null and is not in LinkageNode.linkage.
  - isOutcrossing
```
public boolean isOutcrossing()
```
    Check if parentLink is not null and is not in LinkageNode.linkage.
  - isCrossing
```
public boolean isCrossing()
```
    Check if isIncrossing() or isOutcrossing().
  - makeClosureJoint
```
public Joint makeClosureJoint()
```
    Ensure that this Joint is a chain closure.
    
    Has no effect if this Joint is already a chain closure.
    
    The childLink becomes a new root (see Link.makeRootLink()); it always holds its absolute pose.
  - makeTreeJoint
```
public Joint makeTreeJoint()
```
    Ensure that this Joint is a tree joint iff it's connected.
    
    Has no effect if this Joint is not currently connected or is already a tree joint.
    
    The previous parent of childLink becomes a chain closure on it. A re-=grounding is triggered if not isCrossing() and childLink Link.isGroundLink(), or if isOutcrossing(): in the former case parentLink made the new ground link of LinkageNode.linkage, in the latter case childLink is made the new ground link.
    
    childLink always holds its absolute pose.
    
    Throws:
    
    java.lang.IllegalArgumentException - if isIncrossing(), and the Linkage.disposition of LinkageNode.linkage is Linkage.Disposition.DRIVEN
    
    java.lang.IllegalArgumentException - if isIncrossing(), and childLink is the ground link in the Linkage enclosing LinkageNode.linkage
  - invert
```
public Joint invert()
```
    Invert both the topology and the geometry of this Joint.
    
    If this is a closure joint then
    1. parentLink and childLink are swapped
    2. childToMobilityRX and mobilityToParentRX are swapped and inverted
    3. mobilityInverted is toggled
    4. recomputeJointRX()
    If this is a tree joint then this triggers a re-grounding, making childLink the new ground:
    1. all the tree joints in the path to the current ground link, including this joint, are collected as path and temporarily converted to closure joints
    2. childLink is Link.makeGroundLink() now that it's a root link
    3. all joints in path are inverted now that they're closure joints
    4. all joints in path are converted back to tree joints.
    Throws:
    
    java.lang.IllegalStateException - if isTreeJoint() and isCrossing()
    
    java.lang.IllegalStateException - if this Joint is not auto-named and the new parent Link already has a Joint of the same name, or if the same holds for any joint in the tree path to the current ground link; no mutation is performed
    
    java.lang.IllegalStateException - if attached to either a parent or child link subframe
  - recomputeJointRX
```
public void recomputeJointRX()
```
    Recompute jointRX from childToMobilityRX, mobilityRX, and mobilityToParentRX.
  - recomputeInverse
```
public boolean recomputeInverse(int slackTransform,
                       boolean recomputeJointRX)
```
    Possibly recompute jointRX to fit the current parentLink and childLink LinkageNode.cmts, then recompute one of the three internal transforms RX_MOBILITY, RX_CHILD_TO_MOBILITY, or RX_MOBILITY_TO_PARENT to take up the slack left by the other two incomposing (the new) jointRX.
    
    The slack transform is never clamped. If it's mobilityRX, then handleMobilityChange(boolean) will take care of updating mobilityRXClamped as appropriate. If the slack transform is childToMobilityRX or mobilityToParentRX then first mobilityRX will be set to mobilityRXClamped.
    
    Parameters:
    slackTransform - the sub-transform selected to take up the slack: RX_MOBILITY, RX_CHILD_TO_MOBILITY, or RX_MOBILITY_TO_PARENT
    recomputeJointRX - whether to first recompute jointRX from the adjacent Link CMTs.
    
    Returns:
    true iff any changes were made due to clamping
    
    Throws:
    
    java.lang.IllegalStateException - if recomputeJointRX and this Joint is not currently connected
  - recomputeInverse
```
public boolean recomputeInverse(int slackTransform)
```
    Covers recomputeInverse(int, boolean), always recomputes jointRX.
  - recomputeInverse
```
public boolean recomputeInverse()
```
    Covers recomputeInverse(int, boolean), always recomputes jointRX and puts the slack in RX_MOBILITY.
  - recomputeInverse
```
protected boolean recomputeInverse(vona.math.RX slackRX,
                       vona.math.RX parentCMT,
                       vona.math.RX childCMT)
```
    Recompute jointRX from the given adjacent Link CMTs, then recompute the indicated slackRX.
    
    Returns:
    true iff any changes were made due to clamping
  - recomputeInverse
```
protected boolean recomputeInverse(vona.math.RX slackRX)
```
    Recompute the indicated slackRX based on the current jointRX.
    
    Returns:
    true iff any changes were made due to clamping
  - clampToLimits
```
public boolean clampToLimits(vona.math.RX rx)
```
    Clamp rx to the current mobility space limits.
    
    This ensures that the transform respects both DoI and any set DoF limits.
    
    Returns:
    true iff clamped anything
  - clampDoFToLimits
```
public double clampDoFToLimits(int index,
                      double value)
```
    Clamp DoF component value to the current limits for the DoF at index.
  - isHardGoalSubtransform
```
public static boolean isHardGoalSubtransform(int which)
```
    check if the indicated sub-transform is a hard goal
  - isSoftGoalSubtransform
```
public static boolean isSoftGoalSubtransform(int which)
```
    check if the indicated sub-transform is a soft goal
  - isMobilitySpaceSubtransform
```
public static boolean isMobilitySpaceSubtransform(int which)
```
    Check if the indicated sub-transform is RX_MOBILITY or a hard or soft goal.
  - isGoalSubtransform
```
public static boolean isGoalSubtransform(int which)
```
    check if the indicated sub-transform is a goal
  - isPositioningSubtransform
```
public static boolean isPositioningSubtransform(int which)
```
    check if the indicated sub-transform positions the mobility space
  - isChainSubtransform
```
public static boolean isChainSubtransform(int which)
```
    check if the indicated sub-transform is in the child-to-parent chain
  - otherPositioningTransform
```
public static int otherPositioningTransform(int which)
```
    return the opposite mobility space positioning transform
  - setSubRX
```
public boolean setSubRX(int which,
               int slackRX,
               vona.math.RX rx)
```
    Set one of the sub-transforms.
    
    The mutated transform is clamped to current limits if it isMobilitySpaceSubtransform(int).
    
    Requests to unset RX_LOCK are handled by deferring to setLocked(boolean).
    
    Requests to set RX_LOCK are only valid if currently locked. In that case, the request is internally handled the same as RX_MOBILITY for all but connected closure joints. Recall that lockRX will automatically track mobilityRX except for connected closures.
    
    Parameters:
    which - the sub-transform identifier. Only RX_INVARIANT cannot be explicitly mutated. RX_LOCK can be mutated only if isLocked().
    slackRX - if non-negative then the current jointRX will be held and the indicated sub-transform will receive slack in a recomputeInverse(int, boolean); if negative then jointRX will be recomputed.
    rx - the new transform, passed by copy. Null triggers an un-set for goal transforms and is treated as identity for the others.
    
    Returns:
    true iff any changes were made due to clamping
    
    Throws:
    
    java.lang.IllegalStateException - if which is RX_LOCK and not isLocked()
  - setSubRX
```
public boolean setSubRX(int which,
               vona.math.RX rx)
```
    setSubRX(int, int, RX) recomputing jointRX.
  - setSoftGoal
```
public boolean setSoftGoal(int which,
                  vona.math.RX rx)
```
    setSubRX(int, RX) on RX_TARGET or RX_POSTURE.
  - setChildToMobility
```
public void setChildToMobility(vona.math.RX rx)
```
    setSubRX(int, RX) on RX_CHILD_TO_MOBILITY
  - setMobility
```
public boolean setMobility(vona.math.RX rx)
```
    setSubRX(int, RX) on RX_MOBILITY
  - setMobilityToParent
```
public void setMobilityToParent(vona.math.RX rx)
```
    setSubRX(int, RX) on RX_MOBILITY_TO_PARENT
  - transformMobility
```
public Joint transformMobility(vona.math.RX rx,
                      java.lang.String inSubFrame)
```
    Transform the mobility frames relative to the given frame.
    
    This modifies one of the positioning transforms childToMobilityRX or mobilityToParentRX, whichever is associated with inSubFrame. The current joint mobility transform mobilityRX and overall joint transform jointRX, will be preserved by recomputing the other positioning transform iff fully connected.
    
    Parameters:
    inSubFrame - the context frame for the transform, e.g. SF_PARENT_MOBILITY
  - transformMobility
```
public Joint transformMobility(vona.math.RX rx)
```
    transformMobility(RX, String) in SF_PARENT_MOBILITY
  - getSubRX
```
public vona.math.RX getSubRX(int which,
                    vona.math.RX rx)
```
    Get a copy of one of the sub-transforms.
    
    Parameters:
    which - the sub-transform identifier, e.g. RX_MOBILITY
    rx - the copy is returned here, consing if null
  - getSubRX
```
public vona.math.RX getSubRX(int which)
```
    covers getSubRX(int, RX), always conses
  - getChildTOMobility
```
public vona.math.RX getChildTOMobility(vona.math.RX rx)
```
    covers getSubRX(int, RX), gets RX_CHILD_TO_MOBILITY
  - getChildToMobilityRX
```
public vona.math.RX getChildToMobilityRX()
```
    Covers getSubRX(int, RX), gets RX_CHILD_TO_MOBILITY and conses.
  - getMobility
```
public vona.math.RX getMobility(vona.math.RX rx)
```
    covers getSubRX(int, RX), gets RX_MOBILITY
  - getMobilityRX
```
public vona.math.RX getMobilityRX()
```
    Covers getSubRX(int, RX), gets RX_MOBILITY and conses.
  - getMobilityRXTranslation
```
public double[] getMobilityRXTranslation(double[] translation)
```
    get a copy of the translation part of RX_MOBILITY
  - getMobilityRXTranslation
```
public double[] getMobilityRXTranslation()
```
    getMobilityRXTranslation(double[]), conses
  - getMobilityToParent
```
public vona.math.RX getMobilityToParent(vona.math.RX rx)
```
    covers getSubRX(int, RX), gets RX_MOBILITY_TO_PARENT
  - getMobilityToParentRX
```
public vona.math.RX getMobilityToParentRX()
```
    Covers getSubRX(int, RX), gets RX_MOBILITY_TO_PARENT and conses.
  - getSubRXRef
```
public vona.math.RX getSubRXRef(int which)
```
    Get a reference to one of the sub-transforms, do not modify.
    
    Parameters:
    which - the sub-transform identifier, e.g. RX_MOBILITY
  - setChildToMobility
```
public void setChildToMobility(Link child)
```
    recomputeInverse(int) as if our child was child and put the slack in RX_CHILD_TO_MOBILITY.
  - setMobilityToParent
```
public void setMobilityToParent(Link parent)
```
    recomputeInverse(int) as if our parent was parent and put the slack in RX_MOBILITY_TO_PARENT.
  - setMobilityToGoal
```
public Joint setMobilityToGoal(int which)
```
    Set mobilityRX to the current value of the indicated goal.
    
    Parameters:
    which - the goal transform identifier
  - setMobilityToTarget
```
public Joint setMobilityToTarget()
```
    setMobilityToGoal(int) RX_TARGET
  - setMobilityToPosture
```
public Joint setMobilityToPosture()
```
    setMobilityToGoal(int) RX_POSTURE
  - setMobilityToInvariant
```
public Joint setMobilityToInvariant()
```
    setMobilityToGoal(int) RX_INVARIANT
  - setMobilityToLock
```
public Joint setMobilityToLock()
```
    setMobilityToGoal(int) RX_LOCK
  - setMobilityToStiffnessRest
```
public Joint setMobilityToStiffnessRest()
```
    Set the mobility DoF to the stiffnessRest.
    
    Throws:
    
    java.lang.IllegalStateException - if this is not a 1-DoF Joint
  - setMobilityToGravityRest
```
public Joint setMobilityToGravityRest()
```
    Set the mobility DoF to zero gravitational potential energy stored in this joint.
    
    Throws:
    
    java.lang.IllegalStateException - if this is not a RootJoint. See RootJoint.setMobilityToGravityRest() otherwise.
  - setSoftGoalToMobility
```
public Joint setSoftGoalToMobility(int which)
```
    Opposite of setMobilityToGoal(int).
    
    The current impl does not actually change setGoalComponents.
  - setTargetToMobility
```
public Joint setTargetToMobility()
```
    covers setSoftGoalToMobility(int)
  - setPostureToMobility
```
public Joint setPostureToMobility()
```
    covers setSoftGoalToMobility(int)
  - setLockToMobility
```
public Joint setLockToMobility()
```
    opposite of setMobilityToLock()
  - setStiffnessRestToMobility
```
public Joint setStiffnessRestToMobility()
```
    Set stiffnessRest to the current mobility DoF.
    
    Throws:
    
    java.lang.IllegalStateException - if this is not a 1-DoF Joint
  - hasGoal
```
public boolean hasGoal(int which)
```
    check if a goal is currently set
  - getHighestPrioritySoftGoal
```
public int getHighestPrioritySoftGoal()
```
    Get the id of the highest-priority "soft" goal that is currently set.
    
    RX_TARGET and RX_POSTURE are soft goals; RX_INVARIANT and RX_LOCK are hard goals.
    
    Returns:
    RX_TARGET, if set, else RX_POSTURE, if set, else -1
  - getNumGoalComponentsSet
```
public int getNumGoalComponentsSet(int which)
```
    Get the number of TXEM components currently set for RX_INVARIANT, RX_LOCK, RX_TARGET, RX_POSTURE, or G_LIMIT.
    
    Potential goals are not supported.
  - getNumTranslationGoalComponentsSet
```
public int getNumTranslationGoalComponentsSet(int which)
```
    Like getNumGoalComponentsSet(int) but only returns translational components.
  - getNumRotationGoalComponentsSet
```
public int getNumRotationGoalComponentsSet(int which)
```
    Like getNumGoalComponentsSet(int) but only returns rotational components.
  - getSetGoalComponents
```
public int[] getSetGoalComponents(int which)
```
    Get a ref to a cached array containing the indices of the currently set components for the indicated goal, RX_INVARIANT, RX_LOCK, RX_TARGET, RX_POSTURE, or G_LIMIT, if any.
    
    Potential goals are not supported.
    
    Returns a zero-length array if no components of the goal are currently set.
  - getUnsetGoalComponents
```
public int[] getUnsetGoalComponents(int which)
```
    complimentary to getSetGoalComponents(int)
  - getSetTranslationGoalComponents
```
public int[] getSetTranslationGoalComponents(int which)
```
    Like getSetGoalComponents(int) but restricted to translation components.
  - getSetRotationGoalComponents
```
public int[] getSetRotationGoalComponents(int which)
```
    Like getSetGoalComponents(int) but restricted to rotation components.
  - getSetGoalComponentNames
```
public java.lang.String[] getSetGoalComponentNames(int which,
                                          int start,
                                          java.lang.String[] names)
```
    like getSetGoalComponents(int) but gets TXEM component names
  - getSetGoalComponentNames
```
public java.lang.String[] getSetGoalComponentNames(int which,
                                          java.lang.String[] names)
```
    getSetGoalComponentNames(int, int, String[]) starting at 0
  - getSetGoalComponentNames
```
public java.lang.String[] getSetGoalComponentNames(int which)
```
    getSetGoalComponentNames(int, int, String[]) starting at 0 and consing.
  - getGoalStatus
```
public java.lang.String[] getGoalStatus(int which,
                               int start,
                               java.lang.String[] status)
```
    Get the status, "set" or "unset" of each goal component.
  - getGoalStatus
```
public java.lang.String[] getGoalStatus(int which,
                               java.lang.String[] status)
```
    getGoalStatus(int, int, String[]), starting at 0
  - getGoalStatusString
```
public java.lang.String[] getGoalStatusString(int which)
```
    getGoalStatus(int, int, String[]), starting at 0 and consing
  - getGoalStatus
```
public boolean[] getGoalStatus(int which,
                      int start,
                      boolean[] status)
```
    like getGoalStatus(int, int, String[])
  - getGoalStatus
```
public boolean[] getGoalStatus(int which,
                      boolean[] status)
```
    getGoalStatus(int, int, boolean[]), starting at 0
  - getGoalStatusBoolean
```
public boolean[] getGoalStatusBoolean(int which)
```
    getGoalStatus(int, int, boolean[]), starting at 0 and consing
  - hasAnyGoal
```
public boolean hasAnyGoal()
```
    Check if any component of any goal is currently set or hasPotential() or isDoFLimited().
    
    This will effectively return true if hasInvariant() because it will check for any set RX_INVARIANT goals.
  - hasEitherSoftGoal
```
public boolean hasEitherSoftGoal()
```
    Check if either RX_TARGET or RX_POSTURE is currently set.
  - hasTarget
```
public boolean hasTarget()
```
    hasGoal(int) RX_TARGET
  - hasPosture
```
public boolean hasPosture()
```
    hasGoal(int) RX_POSTURE
  - hasInvariant
```
public boolean hasInvariant()
```
    hasGoal(int) RX_INVARIANT
  - hasLock
```
public boolean hasLock()
```
    hasGoal(int) RX_LOCK
  - hasStiffness
```
public boolean hasStiffness()
```
    Check if this Joint has stiffness.
    
    A Joint has stiffness when potentialEnabled, stiffness is not NaN, and there is exactly one DoF.
    
    Also see isStiffnessSet(), which is less restrictive.
  - hasGravity
```
public boolean hasGravity()
```
    Check if this Joint has gravity.
    
    Default impl returns false. See RootJoint.hasGravity().
  - hasPotential
```
public boolean hasPotential()
```
    check either hasStiffness() or hasGravity()
  - setPotentialEnabled
```
public boolean setPotentialEnabled(boolean enabled)
```
    Enable or disable potential goal, if any.
  - enablePotential
```
public boolean enablePotential()
```
    covers setPotentialEnabled(boolean)
  - disablePotential
```
public boolean disablePotential()
```
    covers setPotentialEnabled(boolean)
  - isPotentialEnabled
```
public boolean isPotentialEnabled()
```
    check potential goal gating enable
  - getPotentialGoal
```
public int getPotentialGoal()
```
    Get the currently set potential goal, PG_STIFFNESS or PG_GRAVITY, or -1 if none.
  - isPotentialGoal
```
public static boolean isPotentialGoal(int goal)
```
    Check if goal is one of the potential goals PG_POTENTIAL (itself a meta-goal), PG_STIFFNESS, or PG_GRAVITY.
  - unsetSoftGoal
```
public Joint unsetSoftGoal(int which)
```
    un-set current RX_TARGET or RX_POSTURE
  - unsetSoftGoals
```
public Joint unsetSoftGoals()
```
    un-set both RX_TARGET or RX_POSTURE
  - unsetTarget
```
public Joint unsetTarget()
```
    unsetSoftGoal(int) RX_TARGET
  - unsetPosture
```
public Joint unsetPosture()
```
    unsetSoftGoal(int) RX_POSTURE
  - unsetLock
```
public Joint unsetLock()
```
    chains to setLocked(boolean)
  - setStiffness
```
public double setStiffness(double stiffness)
```
    Set the joint stiffness.
    
    NaN is equivalent to unsetStiffness().
    
    Returns:
    the old value
    
    Throws:
    
    java.lang.IllegalArgumentException - if stiffness is negative
  - unsetStiffness
```
public double unsetStiffness()
```
    setStiffness(double) NaN
  - getStiffness
```
public double getStiffness()
```
    get stiffness or NaN if unset
  - isStiffnessSet
```
public boolean isStiffnessSet()
```
    Check if stiffness is set (not NaN).
    
    Also see hasStiffness(), which is more restrictive.
  - setStiffnessRest
```
public boolean setStiffnessRest(double stiffnessRest)
```
    Set stiffnessRest.
    
    Returns:
    true iff stiffnessRest was clamped to current DoF limits
    
    Throws:
    
    java.lang.IllegalArgumentException - if this is not a 1-DoF joint
  - getStiffnessRest
```
public double getStiffnessRest()
```
    get stiffnessRest
  - getStiffnessPotential
```
public double getStiffnessPotential()
```
    Get the current potential energy stored in this Joint's stiffness, if any.
    
    See getStiffnessPotential(double).
  - getStiffnessPotential
```
public double getStiffnessPotential(double mobilityDoF)
```
    Impl of getStiffnessPotential().
    
    Parameters:
    mobilityDoF - the value to use for the current state of the mobility DoF of this joint, typically getSingleMobilityDoF()
    
    Returns:
    0 if not isStiffnessSet() or this is not a 1-DoF joint, else 0.5*stiffness*(d-stiffnessRest)^2 where d is the current mobility state of the Joint's DoF
  - getGravityPotential
```
public double getGravityPotential()
```
    Get the current potential energy stored by this joint due to gravity.
    
    See getGravityPotential(RX).
  - getGravityPotential
```
public double getGravityPotential(vona.math.RX mobilityRX)
```
    Impl of getGravityPotential().
    
    Default impl returns 0. See RootJoint.getGravityPotential(vona.math.RX).
    
    Parameters:
    mobilityRX - the value to use for the current state of the mobility of this joint, typically mobilityRX
  - getPotential
```
public double getPotential(int which)
```
    Get the indicated potential energy value.
    
    Parameters:
    which - PG_STIFFNESS, PG_GRAVITY, or PG_POTENTIAL to auto-select via getPotentialGoal()
  - getPotential
```
public double getPotential()
```
    like getPotential(int) but always auto-selects
  - setDoF
```
public boolean setDoF(int which,
             int[] dofIndex,
             int start,
             double... dof)
```
    Set the Degree of Freedom values of the RX_TARGET, RX_LOCK, RX_POSTURE, or RX_MOBILITY RX treated as a packed translation and exponential map vector.
    
    Clamping is performed on the modified transform if it is a goal transform or if it is RX_MOBILITY and this is a tree or disconnected Joint.
    
    Requests to unset RX_LOCK are handled by deferring to setLocked(boolean).
    
    Requests to set RX_LOCK are only valid if currently locked. In that case, the request is internally handled the same as RX_MOBILITY for all but connected closure joints. Recall that lockRX will automatically track mobilityRX except for connected closures.
    
    Parameters:
    dofIndex - the indices to set, or null to set all DoF for the current type
    dof - the new Degree of Freedom values in order and length corresponding to dofIndex, or null to use the Joint.Type.dofIndex of the current type of this Joint, or null or empty to un-set a goal. NaN elements are allowed to set a partial goal, but are not allowed when setting mobility.
    
    Returns:
    true iff any changes were made due to clamping
    
    Throws:
    
    java.lang.IllegalArgumentException - if the length of dof is insufficient
    
    java.lang.IllegalArgumentException - if which is RX_MOBILITY and any of the source dof is NaN
    
    java.lang.IllegalStateException - if which is RX_LOCK and not isLocked()
  - setDoF
```
public boolean setDoF(int which,
             int[] dofIndex,
             double... dof)
```
    setDoF(int, int[], int, double...) starting at 0
  - setDoF
```
public boolean setDoF(double... dof)
```
    setDoF(int, int[], int, double...) all Joint.Type.dofIndex starting at 0 and setting RX_MOBILITY.
  - setMobilityDoF
```
public boolean setMobilityDoF(int[] dofIndex,
                     int start,
                     double... dof)
```
    Impl of setDoF(int, int[], int, double...) for setting RX_MOBILITY.
  - setMobilityDoF
```
public boolean setMobilityDoF(int[] dofIndex,
                     double... dof)
```
    setMobilityDoF(int[], int, double...) starting at 0
  - setMobilityDoF
```
public boolean setMobilityDoF(int start,
                     double... dof)
```
    setMobilityDoF(int[], int, double...) sets all DoF
  - setMobilityDoF
```
public boolean setMobilityDoF(double... dof)
```
    setMobilityDoF(int[], int, double...) all Joint.Type.dofIndex starting at 0.
  - setSoftGoalDoF
```
public boolean setSoftGoalDoF(int which,
                     int[] dofIndex,
                     boolean partial,
                     boolean onlyIfDifferent,
                     int start,
                     double... dof)
```
    Impl of setDoF(int, int[], int, double...) and other APIs for setting RX_TARGET or RX_POSTURE DoF.
    
    Parameters:
    dofIndex - the TXEM indices to set, may be a subset of the current type Joint.Type.dofIndex, or null to set all DoF
    partial - whether this is a partial goal. If so, previously set goal components outside dofIndex are left set. If not, components outside dofIndex are unset (NaN specified dof are always unset).
    onlyIfDifferent - whether to not set components that match the current mobility (matching components that are already set will not be unset)
    start - the read start index in dof
    dof - the values to set, if NaN then the corresponding goal component is marked as not set and will track mobilityRX
    
    Returns:
    true if any changes were made to the goal
  - setSoftGoalRX
```
public boolean setSoftGoalRX(int which,
                    int[] dofIndex,
                    boolean partial,
                    boolean onlyIfDifferent,
                    vona.math.RX rx,
                    vona.math.RX compareUnsetComponentsTo)
```
    Like setSoftGoalDoF(int, int[], boolean, boolean, int, double...) but reads source values from an RX.
    
    Parameters:
    compareUnsetComponentsTo - if non-null then comparisons supporting onlyIfDifferent for goal components that are not curently set are made against this transform, else they are made against the current value of the mobility transform
  - setSoftGoalRXOrDoF
```
protected boolean setSoftGoalRXOrDoF(int which,
                         int[] dofIndex,
                         boolean partial,
                         boolean onlyIfDifferent,
                         int start,
                         java.lang.Object rxOrDoF,
                         vona.math.RX compareUnsetComponentsTo)
```
    Common impl of setSoftGoalDoF(int, int[], boolean, boolean, int, double...) and setSoftGoalRX(int, int[], boolean, boolean, RX, RX).
  - setSoftGoalDoF
```
public boolean setSoftGoalDoF(int which,
                     int[] dofIndex,
                     boolean partial,
                     boolean onlyIfDifferent,
                     double... dof)
```
    setSoftGoalDoF(int, int[], boolean, boolean, int, double...) starting at 0.
  - setSoftGoalDoF
```
public boolean setSoftGoalDoF(int which,
                     int[] dofIndex,
                     double... dof)
```
    setSoftGoalDoF(int, int[], boolean, boolean, int, double...) partial but even if not different from current mobility, starting at 0.
  - setSoftGoalDoF
```
public boolean setSoftGoalDoF(int which,
                     double... dof)
```
    setSoftGoalDoF(int, int[], boolean, boolean, int, double...) all Joint.Type.dofIndex even if not different from current mobility, starting at 0.
  - setTranslation
```
public boolean setTranslation(double... dof)
```
    Like setMobilityDoF(double...) but only sets translation components.
  - setRotation
```
public boolean setRotation(double... dof)
```
    Like setMobilityDoF(double...) but only sets EM rotation components.
  - setTarget
```
public boolean setTarget(double... dof)
```
    setSoftGoalDoF(int, double...) on RX_POSTURE
  - setPosture
```
public boolean setPosture(double... dof)
```
    setSoftGoalDoF(int, double...) on RX_POSTURE
  - setLock
```
public boolean setLock(double... dof)
```
    setDoF(int, int[], int, double...) on RX_LOCK
  - setTargetTranslation
```
public boolean setTargetTranslation(double... dof)
```
    Like setDoF(int, int[], int, double...) on RX_TARGET but only sets translation components.
    
    Currently set rotation components for this goal, if any, are not modified.
  - setTargetRotation
```
public boolean setTargetRotation(double... dof)
```
    Like setDoF(int, int[], int, double...) on RX_TARGET but only sets EM rotation components.
    
    Currently set translation components for this goal, if any, are not modified.
  - setPostureTranslation
```
public boolean setPostureTranslation(double... dof)
```
    Like setDoF(int, int[], int, double...) on RX_POSTURE but only sets translation components.
    
    Currently set rotation components for this goal, if any, are not modified.
  - setPostureRotation
```
public boolean setPostureRotation(double... dof)
```
    Like setDoF(int, int[], int, double...) on RX_POSTURE but only sets EM rotation components.
    
    Currently set translation components for this goal, if any, are not modified.
  - setLockTranslation
```
public boolean setLockTranslation(double... dof)
```
    Like setDoF(int, int[], int, double...) on RX_LOCK but only sets translation components.
    
    Currently set rotation components for this goal, if any, are not modified.
  - setLockRotation
```
public boolean setLockRotation(double... dof)
```
    Like setDoF(int, int[], int, double...) on RX_LOCK but only sets EM rotation components.
    
    Currently set translation components for this goal, if any, are not modified.
  - setUnsetGoalDoFtoNaN
```
public double[] setUnsetGoalDoFtoNaN(int which,
                            double[] dof)
```
    Set all components of dof that correspond to unset DoF of goal which to NaN.
  - getDoF
```
public double[] getDoF(int which,
              int[] dofIndex,
              int start,
              double[] dof,
              boolean getEMAliasInLimits)
```
    Retrieve the current Degree of Freedom values of the packed translation and exponential map vector corresponding to a goal or to the mobility sub-transform.
    
    Note that each TXEM component of each soft goal (RX_TARGET and RX_POSTURE) can be independently set or unset. The numeric value of unset components tracks the corresponding actual mobility DoF. See setUnsetGoalDoFtoNaN(int, double[]) to have those components marked as NaN instead.
    
    Parameters:
    which - the sub-transform to read, must be a mobility space transform (i.e. RX_MOBILITY or a goal like RX_TARGET)
    dofIndex - the indices to get, or null to get all DoF for the current type
    start - the write start index in dof
    dof - the dof are written here on return, or a new array is consed if null
    getEMAliasInLimits - whether to ensure that the returned EM components correspond to a (possibly non-canonical) alias of the requested EM vector which falls within any defined limits. Currently only checks the alias within radius 2PI of EM space origin. If getEMAliasInLimits is false then the canonical EM vector is always reutrned.
  - getDoF
```
public double[] getDoF(int which,
              int[] dofIndex,
              double[] dof)
```
    getDoF(int, int[], int, double[], boolean) with EM ailias in limits.
  - getDoF
```
public double[] getDoF(int which,
              int start,
              double[] dof)
```
    getDoF(int, int[], int, double[], boolean) with EM ailias in limits.
  - getDoF
```
public double[] getDoF(int which,
              double[] dof)
```
    getDoF(int, int[], int, double[], boolean) with EM ailias in limits.
  - getDoF
```
public double[] getDoF(int which)
```
    getDoF(int, int[], int, double[], boolean) with EM ailias in limits.
  - getDoF
```
public double[] getDoF()
```
    getDoF(int, int[], int, double[], boolean) getting RX_MOBILITY with EM ailias in limits.
  - getMobility
```
public double[] getMobility(int start,
                   double[] dof,
                   boolean getEMAliasInLimits)
```
    getDoF(int, int[], int, double[], boolean) getting RX_MOBILITY.
  - getMobility
```
public double[] getMobility(double[] dof)
```
    getDoF(int, int[], int, double[], boolean) getting RX_MOBILITY, starting at 0, and always getting EM alias in limits.
  - getMobilityDoF
```
public double[] getMobilityDoF()
```
    getDoF(int, int[], int, double[], boolean) getting RX_MOBILITY, consing, and always getting EM alias in limits.
  - getRotation
```
public double[] getRotation(int start,
                   double[] dof)
```
    getDoF(int, int[], int, double[], boolean) getting RX_MOBILITY with EM ailias in limits, rotation DoF only.
  - getRotation
```
public double[] getRotation(double[] dof)
```
    getDoF(int, int[], int, double[], boolean) getting RX_MOBILITY with EM ailias in limits, rotation DoF only.
  - getRotation
```
public double[] getRotation()
```
    getDoF(int, int[], int, double[], boolean) getting RX_MOBILITY with EM ailias in limits, rotation DoF only.
  - getTranslation
```
public double[] getTranslation(int start,
                      double[] dof)
```
    getDoF(int, int[], int, double[], boolean) getting RX_MOBILITY translation DoF only.
  - getTranslation
```
public double[] getTranslation(double[] dof)
```
    getDoF(int, int[], int, double[], boolean) getting RX_MOBILITY translation DoF only.
  - getTranslation
```
public double[] getTranslation()
```
    getDoF(int, int[], int, double[], boolean) getting RX_MOBILITY translation DoF only.
  - getSubFrameRX
```
public vona.math.RX getSubFrameRX(java.lang.String frame,
                         vona.math.RX rx,
                         boolean clamped)
```
    Impl of getSubFrameRX(String, RX).
    
    Parameters:
    clamped - whether to use mobilityRXClamped instead of mobilityRX if they differ
  - getSubFrameRX
```
public vona.math.RX getSubFrameRX(java.lang.String frame,
                         vona.math.RX rx)
```
    Get the transform taking coordinates in a sub-frame to the canonical (i.e. LinkageNode.cmt) frame of this LinkageNode.
    
    This impl extends superclass impl to handle the various Joint sub-frames.
    
    Overrides:
    
    getSubFrameRX in class LinkageNode
    
    Parameters:
    frame - the sub-frame or null to imply LinkageNode.SF_CANONICAL
    rx - the transform is written here on return, consing if null
    
    Returns:
    a reference to rx
  - getSubFrameRX
```
public vona.math.RX getSubFrameRX(int subXForm,
                         vona.math.RX rx)
```
    Convenience cover of getSubFrameRX(String, RX) using getParentSubFrame().
  - getSubFrameRX
```
public vona.math.RX getSubFrameRX(int subXForm)
```
    getSubFrameRX(int, RX), conses
  - getSubFrameCMT
```
public vona.math.RX getSubFrameCMT(java.lang.String frame,
                          vona.math.RX rx,
                          boolean clamped)
```
    Convenience method appends LinkageNode.cmt to getSubFrameRX(String, RX, boolean).
  - getSubFrameCMT
```
public vona.math.RX getSubFrameCMT(java.lang.String frame,
                          vona.math.RX rx)
```
    Convenience method appends LinkageNode.cmt to LinkageNode.getSubFrameRX(String, RX).
    
    This impl extends superclass impl to handle the various Joint sub-frames.
    
    Overrides:
    
    getSubFrameCMT in class LinkageNode
  - getSubFrameCMT
```
public vona.math.RX getSubFrameCMT(int subXForm,
                          vona.math.RX rx)
```
    Convenience cover of getSubFrameCMT(String, RX) using getParentSubFrameOf(int).
  - getSubFrameCMT
```
public vona.math.RX getSubFrameCMT(int subXForm)
```
    getSubFrameCMT(int, RX), conses
  - getParentSubFrameOf
```
public static java.lang.String getParentSubFrameOf(int subXForm)
```
    Get the name of the sub-frame to which the sub-transform subXForm attaches.
  - unAliasSubFrame
```
public java.lang.String unAliasSubFrame(java.lang.String subFrame)
```
    Dereference SF_MOBILITY_FROM and SF_MOBILITY_TO according to the current value of mobilityInverted.
  - getJointRX
```
public vona.math.RX getJointRX(vona.math.RX rx)
```
    get a copy of jointRX, consing if null
  - getJointRX
```
public vona.math.RX getJointRX()
```
    covers getJointRX(RX), always conses
  - getJointRXRef
```
public vona.math.RX getJointRXRef()
```
    get a ref to jointRX, do not mutate
  - isIdentity
```
public boolean isIdentity()
```
    check RX.isIdentity() on jointRX
  - isChildToMobilityIdentity
```
public boolean isChildToMobilityIdentity()
```
    check RX.isIdentity() on childToMobilityRX
  - isMobilityIdentity
```
public boolean isMobilityIdentity()
```
    check RX.isIdentity() on mobilityRX
  - isMobilityInverted
```
public boolean isMobilityInverted()
```
    check if mobilityInverted
  - isMobilityToParentIdentity
```
public boolean isMobilityToParentIdentity()
```
    check RX.isIdentity() on mobilityToParentRX
  - setLocked
```
public LinkageNode setLocked(boolean locked)
```
    lock the state of this node
    This impl sets the locked state of this Joint.
    
    Specified by:
    
    setLocked in class LinkageNode
  - isLocked
```
public boolean isLocked()
```
    check if this node is locked
    This impl checks the locked state of this Joint.
    
    Specified by:
    
    isLocked in class LinkageNode
  - positioningTransformsMutable
```
public boolean positioningTransformsMutable()
```
    Check if RX_CHILD_TO_MOBILITY and RX_MOBILITY_TO_PARENT are mutable.
    
    Default impl returns opposite of positioningTransformsLocked.
  - setPositioningTransformsLocked
```
public Joint setPositioningTransformsLocked(boolean lock)
```
    Flag RX_CHILD_TO_MOBILITY and RX_MOBILITY_TO_PARENT as locked or unlocked.
    
    See positioningTransformsMutable().
  - lockPositioningTransforms
```
public Joint lockPositioningTransforms()
```
    covers setPositioningTransformsLocked(boolean)
  - unlockPositioningTransforms
```
public Joint unlockPositioningTransforms()
```
    covers setPositioningTransformsLocked(boolean)
  - setSoftGoalWeight
```
public Joint setSoftGoalWeight(double weight)
```
    set the softGoalWeight of this Joint
  - getSoftGoalWeight
```
public double getSoftGoalWeight()
```
    get the softGoalWeight of this Joint
  - setSoftGoalPriority
```
public Joint setSoftGoalPriority(float priority)
```
    set the softGoalPriority of this Joint
  - getSoftGoalPriority
```
public float getSoftGoalPriority()
```
    get the softGoalPriority of this Joint
  - getSoftGoalSolveLevel
```
public int getSoftGoalSolveLevel()
```
    get this Joint's softGoalSolveLevel in its solver
  - getSupportSize
```
public int getSupportSize()
```
    get the size of this Joint's support in its solver
  - getSolver
```
public Solver getSolver()
```
    get the solver assigned to this Joint
  - getBranchLink
```
public Link getBranchLink()
```
    get the branchLink of this Joint, if any
  - getJacobianStartColumn
```
public int getJacobianStartColumn()
```
    Get this Joint's jacobianStartColumn in its solver, if any, else negative.
  - getJacobianDoIStartRow
```
public int getJacobianDoIStartRow()
```
    Get this Joint's jacobianDoIStartRow in its solver, if any, else negative.
  - getJacobianLimitStartRow
```
public int getJacobianLimitStartRow()
```
    Get this Joint's jacobianLimitStartRow in its solver, if any, else negative.
  - getJacobianDoFStartRow
```
public int getJacobianDoFStartRow()
```
    Get this Joint's jacobianDoFStartRow in its solver, if any, else negative.
  - isActuator
```
public boolean isActuator()
```
    check if this Joint is an actuator in its solver
  - isEffector
```
public boolean isEffector(int which)
```
    Check if this Joint is an effector of the given type (RX_INVARIANT, G_LIMIT, RX_LOCK, RX_TARGET, RX_POSTURE, or PG_POTENTIAL) in its solver.
  - isEffector
```
public boolean isEffector()
```
    Check if this Joint is an effector of any type in its solver.
  - resetSolveFields
```
public void resetSolveFields()
```
    reset/null solver and related fields
  - setType
```
public Joint.Type setType(Joint.Type type)
```
    Mutate the type of this Joint.
    
    Does nothing if the passed type is the same as the current type.
    
    Any current target, posture, stiffness, and user limits are un-set, and the Joint is LinkageNode.unlock()ed. mobilityInverted is cleared. The current mobilityRX state is then clamped to the DoI of the new type iff this is a tree or disconnected Joint.
    
    Returns:
    the old type
    
    Throws:
    
    java.lang.IllegalArgumentException - if type is null
  - setTypeImpl
```
protected Joint.Type setTypeImpl(Joint.Type type)
```
    Impl of setType(msim.model.Joint.Type), so that RootJoint constr can set initial type but still disable run-time type mutation.
  - checkType
```
public java.lang.String checkType(Joint.Type type)
```
    Check if type is a valid type for this joint in its current connected configuration.
    
    See Link.isConnectableToJointType(java.lang.String, msim.model.Joint.Type).
    
    Returns:
    null if type is a valid type, otherwise a string describing the problem
  - getType
```
public Joint.Type getType()
```
    get the current Joint Joint.Type
  - getTypeName
```
public java.lang.String getTypeName()
```
    returns the lower-cased name of this Joint's type
  - getSubRXName
```
public static java.lang.String getSubRXName(int which)
```
    get the human readable name for the indicated subtransform
  - getPotentialGoalName
```
public static java.lang.String getPotentialGoalName(int which)
```
    get the human readable name for the indicated potential goal
  - isLimitGoal
```
public static boolean isLimitGoal(int which)
```
    check if which indicates the limit goal
  - getLimitGoalName
```
public static java.lang.String getLimitGoalName()
```
    get the human readable name for the limit goal
  - getGoalName
```
public static java.lang.String getGoalName(int which)
```
    get the human readable name for the indicated goal
  - getNumDoF
```
public int getNumDoF()
```
    get the number of Degrees of Freedom in the current type
  - getNumDoI
```
public int getNumDoI()
```
    get the number of Degrees of Invariance in the current type
  - getNumTranslationDoF
```
public int getNumTranslationDoF()
```
    get the number of translational DoF in the current type
  - getNumRotationDoF
```
public int getNumRotationDoF()
```
    get the number of rotational DoF in the current type
  - getDoFIndices
```
public int[] getDoFIndices(int start,
                  int[] indices)
```
    get the TXEM vector indices of the DoF in the current type
  - getDoFIndices
```
public int[] getDoFIndices(int[] indices)
```
    getDoFIndices(int, int[]) starting at 0
  - getDoFIndices
```
public int[] getDoFIndices()
```
    getDoFIndices(int, int[]) starting at 0 and consing
  - getDoFIndicesRef
```
public int[] getDoFIndicesRef()
```
    Get a reference to the TXEM vector indices of the DoF in the current type.
    
    Returns:
    the indices, do not modify
  - getIndices
```
protected int[] getIndices(int[] source,
               int writeStart,
               int[] dest)
```
    Helper method to copy source to dest, consing if necessary.
  - getDoIIndices
```
public int[] getDoIIndices(int start,
                  int[] indices)
```
    similar to getDoFIndices(int, int[]) but gets Degrees of Invariance
  - getDoIIndices
```
public int[] getDoIIndices(int[] indices)
```
    getDoIIndices(int, int[]) starting at 0
  - getDoIIndices
```
public int[] getDoIIndices()
```
    getDoIIndices(int, int[]) starting at 0 and consing
  - getDoIIndicesRef
```
public int[] getDoIIndicesRef()
```
    similar to getDoFIndicesRef() but gets Degrees of Invariance
  - getTranslationDoFIndices
```
public int[] getTranslationDoFIndices(int start,
                             int[] indices)
```
    similar to getDoFIndices(int, int[]) but restricted to translation
  - getTranslationDoFIndices
```
public int[] getTranslationDoFIndices(int[] indices)
```
    getTranslationDoFIndices(int, int[]) starting at 0
  - getTranslationDoFIndices
```
public int[] getTranslationDoFIndices()
```
    getTranslationDoFIndices(int, int[]) starting at 0 and consing.
  - getTranslationDoFIndicesRef
```
public int[] getTranslationDoFIndicesRef()
```
    similar to getDoFIndicesRef() but restricted to translation
  - getTranslationDoIIndices
```
public int[] getTranslationDoIIndices(int start,
                             int[] indices)
```
    similar to getDoIIndices(int, int[]) but restricted to translation
  - getTranslationDoIIndices
```
public int[] getTranslationDoIIndices(int[] indices)
```
    getTranslationDoIIndices(int, int[]) starting at 0
  - getTranslationDoIIndices
```
public int[] getTranslationDoIIndices()
```
    getTranslationDoIIndices(int, int[]) starting at 0 and consing.
  - getTranslationDoIIndicesRef
```
public int[] getTranslationDoIIndicesRef()
```
    similar to getDoIIndicesRef() but restricted to translation
  - getRotationDoFIndices
```
public int[] getRotationDoFIndices(int start,
                          int[] indices)
```
    similar to getDoFIndices(int, int[]) but restricted to rotation
  - getRotationDoFIndices
```
public int[] getRotationDoFIndices(int[] indices)
```
    getRotationDoFIndices(int, int[]) starting at 0
  - getRotationDoFIndices
```
public int[] getRotationDoFIndices()
```
    getRotationDoFIndices(int, int[]) starting at 0 and consing.
  - getRotationDoFIndicesRef
```
public int[] getRotationDoFIndicesRef()
```
    similar to getDoFIndicesRef() but restricted to rotation
  - getRotationDoIIndices
```
public int[] getRotationDoIIndices(int start,
                          int[] indices)
```
    similar to getDoIIndices(int, int[]) but restricted to rotation
  - getRotationDoIIndices
```
public int[] getRotationDoIIndices(int[] indices)
```
    getRotationDoIIndices(int, int[]) starting at 0
  - getRotationDoIIndices
```
public int[] getRotationDoIIndices()
```
    getRotationDoIIndices(int, int[]) starting at 0 and consing.
  - getRotationDoIIndicesRef
```
public int[] getRotationDoIIndicesRef()
```
    similar to getDoIIndicesRef() but restricted to rotation
  - getNames
```
protected java.lang.String[] getNames(java.lang.String[] source,
                          int writeStart,
                          java.lang.String[] dest)
```
    like getIndices(int[], int, int[]) but gets TXEM component names
  - getDoFNames
```
public java.lang.String[] getDoFNames(int start,
                             java.lang.String[] names)
```
    like getDoFIndices(int, int[]) but gets TXEM component names
  - getDoFNames
```
public java.lang.String[] getDoFNames(java.lang.String[] names)
```
    getDoFNames(int, String[]) starting at 0
  - getDoFNames
```
public java.lang.String[] getDoFNames()
```
    getDoFNames(int, String[]) starting at 0 and consing
  - getDoINames
```
public java.lang.String[] getDoINames(int start,
                             java.lang.String[] names)
```
    like getDoIIndices(int, int[]) but gets TXEM component names
  - getDoINames
```
public java.lang.String[] getDoINames(java.lang.String[] names)
```
    getDoINames(int, String[]) starting at 0
  - getDoINames
```
public java.lang.String[] getDoINames()
```
    getDoINames(int, String[]) starting at 0 and consing
  - getTranslationDoFNames
```
public java.lang.String[] getTranslationDoFNames(int start,
                                        java.lang.String[] names)
```
    like getTranslationDoFIndices(int, int[]) but gets TXEM component names
  - getTranslationDoFNames
```
public java.lang.String[] getTranslationDoFNames(java.lang.String[] names)
```
    getTranslationDoFNames(int, String[]) starting at 0
  - getTranslationDoFNames
```
public java.lang.String[] getTranslationDoFNames()
```
    getTranslationDoFNames(int, String[]) starting at 0 and consing
  - getTranslationDoINames
```
public java.lang.String[] getTranslationDoINames(int start,
                                        java.lang.String[] names)
```
    like getTranslationDoIIndices(int, int[]) but gets TXEM component names
  - getTranslationDoINames
```
public java.lang.String[] getTranslationDoINames(java.lang.String[] names)
```
    getTranslationDoINames(int, String[]) starting at 0
  - getTranslationDoINames
```
public java.lang.String[] getTranslationDoINames()
```
    getTranslationDoINames(int, String[]) starting at 0 and consing
  - getRotationDoFNames
```
public java.lang.String[] getRotationDoFNames(int start,
                                     java.lang.String[] names)
```
    like getRotationDoFIndices(int, int[]) but gets TXEM component names
  - getRotationDoFNames
```
public java.lang.String[] getRotationDoFNames(java.lang.String[] names)
```
    getRotationDoFNames(int, String[]) starting at 0
  - getRotationDoFNames
```
public java.lang.String[] getRotationDoFNames()
```
    getRotationDoFNames(int, String[]) starting at 0 and consing
  - getRotationDoINames
```
public java.lang.String[] getRotationDoINames(int start,
                                     java.lang.String[] names)
```
    like getRotationDoIIndices(int, int[]) but gets TXEM component names
  - getRotationDoINames
```
public java.lang.String[] getRotationDoINames(java.lang.String[] names)
```
    getRotationDoINames(int, String[]) starting at 0
  - getRotationDoINames
```
public java.lang.String[] getRotationDoINames()
```
    getRotationDoINames(int, String[]) starting at 0 and consing
  - dumpSubJacobian
```
public void dumpSubJacobian(Joint other,
                   java.io.PrintStream s)
```
    Solver.dumpSubJacobian(Joint, Joint, PrintStream) that relates this Joint, whether it's an actuator or an effector, to other in solver, if any.
  - dumpSubJacobian
```
public void dumpSubJacobian(Joint other)
```
    dumpSubJacobian(Joint, PrintStream) to System.out
  - dumpSolverInfo
```
public void dumpSolverInfo(java.io.PrintStream s)
```
    Describing the role of this Joint in its solver, if any.
  - dumpSolverInfo
```
public void dumpSolverInfo()
```
    dumpSolverInfo(PrintStream) to System.out
  - dumpSupport
```
public void dumpSupport(java.io.PrintStream s)
```
    dump the support of this Joint
  - dumpSupport
```
public void dumpSupport()
```
    dumpSupport(PrintStream) to System.out
  - dumpState
```
public void dumpState(java.io.PrintStream s)
```
    dump mobility and related numeric state
  - dumpState
```
public void dumpState()
```
    dumpState(PrintStream) to System.out
  - dumpSubRXState
```
public void dumpSubRXState(java.io.PrintStream s,
                  int which)
```
    one-line dump of the state of one of the sub-transforms
  - dumpSubRXState
```
public void dumpSubRXState(int which)
```
    dumpSubRXState(PrintStream, int) to System.out
  - dump
```
public void dump(java.io.PrintStream s)
```
    dump Joint details
    
    Overrides:
    
    dump in class LinkageNode
  - dumpTree
```
protected void dumpTree(java.lang.String prefix,
            java.io.PrintStream s)
```
    impl of LinkageNode.dumpTree(PrintStream)
    This impl overrides generic impl to note if a joint isIdentity().
    
    Overrides:
    
    dumpTree in class LinkageNode
  - getResidual
```
public double[] getResidual(int which,
                   Joint.ResidualType type,
                   int start,
                   double[] residual)
```
    Compute a differential vector which will satisfy the specified goal when added to the current state of that goal.
    
    Residuals can be requested even for goal components that are not currently set; in that case the corresponding residual components will be zero.
    
    Parameters:
    which - RX_INVARIANT, RX_LOCK, RX_TARGET, RX_POSTURE, PG_POTENTIAL, PG_STIFFNESS, PG_GRAVITY, or G_LIMIT
    start - write start index in residual
    residual - the destination vector, cons if null
    
    Returns:
    a reference to residual
  - getResidual
```
public double[] getResidual(int which,
                   Joint.ResidualType type,
                   double[] residual)
```
    Covers getResidual(int, ResidualType, int, double[]), starts at 0.
  - getResidual
```
public double[] getResidual(int which,
                   Joint.ResidualType type)
```
    Covers getResidual(int, ResidualType, int, double[]), starts at 0 and conses.
    
    Returns:
    a newly consed packed residual vector
  - getLimitExcess
```
public double getLimitExcess(int index)
```
    Get the signed amount by which a particular DoF exceeds its current limits, if any.
    
    The limit excess for a DoF component whose current value is c is
    - 0 if the DoF is not limited or is within limits
    - c-l if the DoF exceeds its upper limit l
    - c-l if the DoF exceeds its lower limit l
  - getLimitExcess
```
public double[] getLimitExcess(vona.math.RX mobilityRX,
                      int[] indices,
                      int start,
                      double[] excess)
```
    Generalizes getLimitExcess(int) to get a vector of excesses.
    
    Parameters:
    mobilityRX - the RX to use as if it were the mobilityRX of this Joint, or null to use the Joint's actual mobilityRX
    indices - the DoF indices for which to compute the excesses, or null to use setLimitComponents
    start - the write start index in excess
    excess - the computed excess is written here, or a new array is consed if null
  - getLimitExcess
```
public double[] getLimitExcess(vona.math.RX mobilityRX,
                      int start,
                      double[] excess)
```
    Covers getLimitExcess(RX, int[], int, double[]), uses setLimitComponents.
  - getLimitExcess
```
public double[] getLimitExcess(int start,
                      double[] excess)
```
    Covers getLimitExcess(RX, int[], int, double[]), uses setLimitComponents and mobilityRX.
  - getLimitExcess
```
public double[] getLimitExcess(double[] excess)
```
    Covers getLimitExcess(RX, int[], int, double[]), uses setLimitComponents and mobilityRX, starts writing at index 0.
  - getLimitExcess
```
public double[] getLimitExcess()
```
    Covers getLimitExcess(RX, int[], int, double[]), uses setLimitComponents and mobilityRX, starts writing at index 0 and conses.
  - getLimitPenalty
```
public double[] getLimitPenalty(vona.math.RX mobilityRX,
                       int[] indices,
                       int start,
                       double[] penalty)
```
    Impl of getResidual(int, ResidualType, int, double[]) for G_LIMIT.
    
    The limit penalty for a DoF component with limit excess (see getLimitExcess(int)) e is e^LIMIT_PENALTY_DEGREE.
    
    Note that the penalty has the opposite sign as the residual.
    
    Parameters:
    mobilityRX - the RX to use as if it were the mobilityRX of this Joint, or null to use the Joint's actual mobilityRX
    indices - the DoF indices for which to compute the penalty, or null to use setLimitComponents
    start - the write start index in penalty
    penalty - the computed penalty is written here, or a new array is consed if null
  - getLimitPenalty
```
public double[] getLimitPenalty(vona.math.RX mobilityRX,
                       int start,
                       double[] penalty)
```
    Covers getLimitPenalty(RX, int[], int, double[]), uses setLimitComponents.
  - getLimitPenalty
```
public double[] getLimitPenalty(int start,
                       double[] penalty)
```
    Covers getLimitPenalty(RX, int[], int, double[]), uses setLimitComponents and mobilityRX.
  - getLimitPenalty
```
public double[] getLimitPenalty(double[] penalty)
```
    Covers getLimitPenalty(RX, int[], int, double[]), uses setLimitComponents and mobilityRX, starts writing at index 0.
  - getLimitPenalty
```
public double[] getLimitPenalty()
```
    Covers getLimitPenalty(RX, int[], int, double[]), uses setLimitComponents and mobilityRX, starts writing at index 0 and conses.
  - isTranslationDoF
```
public boolean isTranslationDoF(int component)
```
    Check if a given translation vector component is a Degree of Freedom according to the current Joint type.
    
    Parameters:
    component - RX.X, RX.Y, or RX.Z
  - isTranslationDoI
```
public boolean isTranslationDoI(int component)
```
    Check if a given translation vector component is a Degree of Invariance according to the current Joint type.
    
    Parameters:
    component - RX.X, RX.Y, or RX.Z
  - isRotationDoF
```
public boolean isRotationDoF(int component)
```
    similar to isTranslationDoF(int)
  - isRotationDoI
```
public boolean isRotationDoI(int component)
```
    similar to isTranslationDoI(int)
  - setTranslationLimits
```
public boolean setTranslationLimits(int component,
                           double min,
                           double max)
```
    Set or un-set the upper and lower limits for one component of the mobility translation vector.
    
    The limits must be either both set or unset.
    
    The current goal transforms, if set, are clamped to the new limits, if any. The mobility transform is also clamped iff this is a tree or disconnected Joint.
    
    Parameters:
    component - RX.X, RX.Y, or RX.Z
    min - the new lower limit, or NaN to unset
    max - the new upper limit, or NaN to unset
    
    Returns:
    true iff any changes were made due to clamping
    
    Throws:
    
    java.lang.IllegalArgumentException - if component is not a translation DoF, if one of min or max is NaN but not the other, or if min>max
  - setAllTranslationLimits
```
public boolean setAllTranslationLimits(double... limits)
```
    Set the LOWER and UPPER limits for all translation DoF.
    
    Parameters:
    limits - an array of limits in order (lower, upper) for each translation DoF, in order
    
    Returns:
    true iff any changes were made due to clamping
  - unsetTranslationLimits
```
public Joint unsetTranslationLimits(int component)
```
    covers setTranslationLimits(int, double, double), always un-sets
  - unsetAllTranslationLimits
```
public Joint unsetAllTranslationLimits()
```
    unsetTranslationLimits(int) all translation DoF
  - setRotationLimits
```
public boolean setRotationLimits(int component,
                        double min,
                        double max)
```
    Similar to setTranslationLimits(int, double, double).
    
    Throws:
    
    java.lang.IllegalArgumentException - if the specified new limits would extend the EM space limit box beyond the sphere of radius 2pi centered at EM space origin. The limits are not modified in this case.
  - setAllRotationLimits
```
public boolean setAllRotationLimits(double... limits)
```
    similar to setAllTranslationLimits(double...)
  - unsetRotationLimits
```
public Joint unsetRotationLimits(int component)
```
    similar to unsetTranslationLimits(int)
  - unsetAllRotationLimits
```
public Joint unsetAllRotationLimits()
```
    similar to unsetAllTranslationLimits()
  - setAllDoFLimits
```
public boolean setAllDoFLimits(double... limits)
```
    similar to setAllTranslationLimits(double...)
  - unsetAllDoFLimits
```
public Joint unsetAllDoFLimits()
```
    similar to unsetAllTranslationLimits()
  - isTranslationLimited
```
public boolean isTranslationLimited(int component)
```
    Check if one component of the mobility translation vector currently has limits set.
    
    Parameters:
    component - RX.X, RX.Y, or RX.Z
    
    Returns:
    true iff the component of translation is either a Degree of Invariance or a Degree of Freedom with set limits
  - isRotationLimited
```
public boolean isRotationLimited(int component)
```
    similar to isTranslationLimited(int)
  - isLimited
```
public boolean isLimited()
```
    check if there are any DoI or if there are limits are set on any DoF
  - isDoFLimited
```
public boolean isDoFLimited()
```
    Check whether any of the DoF of this joint are limited.
    
    This differs from isLimited() because it doesn't count DoI.
  - inDoFLimits
```
public boolean inDoFLimits(double tol)
```
    Check if the current mobility transform is actually within the limits.
  - inDoFLimits
```
public boolean inDoFLimits()
```
    inDoFLimits(double), no tol
  - getTranslationLimit
```
public double getTranslationLimit(int component,
                         int which)
```
    Get the LOWER or UPPER limit of one component of the mobility translation vector.
    
    Parameters:
    component - RX.X, RX.Y, or RX.Z
    which - LOWER or UPPER
    
    Returns:
    the current value of the requested limit, or NaN if unset. If component is a Degree of Invariance then the limit is the value of that invariant.
  - getAllTranslationLimits
```
public double[] getAllTranslationLimits()
```
    Get the upper and lower limits for all translation DoF.
    
    Returns:
    an array of limits in order (lower, upper) for each translation DoF, in order
  - getRotationLimit
```
public double getRotationLimit(int component,
                      int which)
```
    similar to getTranslationLimit(int, int)
  - getAllRotationLimits
```
public double[] getAllRotationLimits()
```
    similar to getAllTranslationLimits()
  - getDoFLimits
```
public double[] getDoFLimits(int which,
                    int start,
                    double[] values)
```
    Get the LOWER or UPPER limits of the Degrees of Freedom, if set.
    
    Parameters:
    which - LOWER or UPPER
    values - the Joint.Type.numDoF limit values are returned here starting at index start in packed order corresponding to the Joint.Type.dofIndex of the current Joint type; NaN signifies the limit is not set. A new array is consed if null.
  - getDoFLimits
```
public double[] getDoFLimits(int which,
                    double[] values)
```
    Covers getDoFLimits(int, int, double[]), starts at 0.
  - getDoFLimits
```
public double[] getDoFLimits(int which)
```
    Covers getDoFLimits(int, int, double[]), starts at 0, always conses.
  - getAllDoFLimits
```
public double[] getAllDoFLimits()
```
    Get the upper and lower limits for all DoF.
    
    Returns:
    an array of limits in order (lower, upper) for each DoF, in order
  - getInvariants
```
public double[] getInvariants(int start,
                     double[] values)
```
    Get the values of the Degrees of Invariance of the current Joint type.
    
    Always returns six values. DoF are returned as NaN.
    
    Parameters:
    values - the Joint.Type.numDoI invariant values are returned here starting at index start in packed order corresponding to the Joint.Type.doiIndex of the current Joint type. A new array is consed if null.
  - getInvariants
```
public double[] getInvariants(double[] values)
```
    Covers getInvariants(int, double[]), starts at 0.
  - getInvariants
```
public double[] getInvariants()
```
    Covers getInvariants(int, double[]), starts at 0 and conses.
  - getInvariant
```
public double getInvariant(int index)
```
    Get the invariant value of a TXEM component, NaN if not an invariant.
  - getPackedInvariantsRef
```
public double[] getPackedInvariantsRef()
```
    Get the values of the Degrees of Invariance of the current Joint type, eliding DoF.
    
    Always returns getNumDoI() values.
  - getLimit
```
public double getLimit(int component,
              int offset,
              int which)
```
    Common impl of getTranslationLimit(int, int) and getRotationLimit(int, int).
  - getLimits
```
public double[] getLimits(int which,
                 int start,
                 double[] ret)
```
    Get a copy of the LOWER or UPPER limits.
    
    Parameters:
    which - LOWER or UPPER
    start - the write start location in ret
    ret - the return buffer or null to cons
    
    Returns:
    a reference to the return buffer
  - getLimits
```
public double[] getLimits(int which,
                 double[] ret)
```
    covers getLimits(int, int, double[]), starts at 0
  - getLimits
```
public double[] getLimits(int which)
```
    covers getLimits(int, int, double[]), conses and starts at 0
  - isDoF
```
public boolean isDoF(int component,
            int offset)
```
    Common impl of isTranslationDoF(int) and isRotationDoF(int).
  - isDoF
```
public boolean isDoF(int component)
```
    check if a TXEM component is a DoF
  - isDoI
```
public boolean isDoI(int component,
            int offset)
```
    Common impl of isTranslationDoI(int) and isRotationDoI(int).
  - isDoI
```
public boolean isDoI(int component)
```
    check if a TXEM component is a DoI
  - isLimited
```
public boolean isLimited(int component,
                int offset)
```
    Common impl of isTranslationLimited(int) and isRotationLimited(int).
  - isLimited
```
public boolean isLimited(int component)
```
    check if a TXEM component is limited
  - setLimits
```
protected boolean setLimits(int component,
                int offset,
                java.lang.String name,
                double min,
                double max)
```
    Common impl of setTranslationLimits(int, double, double) and setRotationLimits(int, double, double).
  - toString
```
public java.lang.String toString(boolean details,
                        boolean connections)
```
    returns a short human-readable identifying string for this Joint
  - toString
```
public java.lang.String toString(boolean details)
```
    covers toString(boolean, boolean), always shows connections
    
    Specified by:
    
    toString in class LinkageNode
  - handleMobilityChange
```
protected boolean handleMobilityChange(boolean overwriteIfClamped)
```
    Hook called whenever mobilityRX or the mobility space has changed.
    
    Clamps mobilityRX to the current limits, putting the result in mobilityRXClamped, and also back into mobilityRX iff overwriteIfClamped. Then updateGoalFromMobility(int) all goals and invalidate cached state that depends on the mobility space.
    
    Parameters:
    overwriteIfClamped - whether to actually update mobilityRX; if not then only mobilityRXClamped is set
    
    Returns:
    true iff any changes were made to mobilityRX
  - handleMobilityChange
```
protected boolean handleMobilityChange()
```
    handleMobilityChange(boolean) and clamp mobilityRX iff isTreeJoint() or not isConnected().
  - updateGoalFromMobility
```
protected boolean updateGoalFromMobility(int which)
```
    Update any un-set TXEM components of goal which from mobilityRX and clamp it to current limits.
    
    Returns:
    true if any changes were made due to clamping
  - getNodeWidgetProperty
```
protected java.lang.String getNodeWidgetProperty()
```
    Return the Widget property name that indicates an internal (i.e. non-user) Widget.
    
    This impl returns WP_JOINT.
    
    Specified by:
    
    getNodeWidgetProperty in class LinkageNode
  - updateWidgetsImpl
```
protected void updateWidgetsImpl()
```
    Hook for lazy LinkageNode.widgetMap update.
    
    Default impl updates all widgets to current LinkageNode.widgetLength, sets their EntityClass.WP_ENTITY_CLASS, and updates existing dbg geometry iff enabled.
    
    This impl takes one of two actions depending on whether the current set of LinkageNode.nodeWidgets is empty. If so, it adds the widgets appropriate for the current joint type (note that the implementation of setType(msim.model.Joint.Type) will clear LinkageNode.nodeWidgets whenever the type is mutated). Otherwise, the widgets in the current set of LinkageNode.nodeWidgets are updated. Finally, this impl chains to superclass impl.
    
    Overrides:
    
    updateWidgetsImpl in class LinkageNode
  - addAxesWidget
```
protected vona.j3d.AxesWidget addAxesWidget(java.lang.String name,
                                java.lang.String frame)
```
    Adds an AxesWidget with AXES_RADIUS_FACTOR radius in indicated frame.
  - updateAxesWidget
```
protected void updateAxesWidget(java.lang.String name,
                    java.lang.String frame)
```
    Retrieves the named AxesWidget and calls updateAxesWidget(AxesWidget, String).
  - updateAxesWidget
```
protected void updateAxesWidget(vona.j3d.AxesWidget w,
                    java.lang.String frame)
```
    Enables or disables the axes depending on whether the corresponding transform is identity, whether the Joint is connected, and if so whether it is attached to a Link subframe. If enabled, the Widget RX is updated to the current widget frame transform for frame.
  - addRouteWidgets
```
protected vona.j3d.RouteWidget addRouteWidgets(java.lang.String name,
                                   java.lang.String frame,
                                   int rx)
```
    Adds route widgets for the indicated sub-transform.
  - updateRouteWidgets
```
protected void updateRouteWidgets(java.lang.String name,
                      java.lang.String frame,
                      int rx)
```
    Retrieves the named route widgets and calls updateRouteWidgets(RouteWidget, ConeWidget, String, int).
  - updateRouteWidgets
```
protected void updateRouteWidgets(vona.j3d.RouteWidget rw,
                      vona.j3d.ConeWidget cw,
                      java.lang.String frame,
                      int rx)
```
    Enables or disables the route widgets, and updates their geometry. If enabled, the Widget RX are updated to the current widget frame transform for frame.
  - addCylinderWidget
```
protected vona.j3d.CylinderWidget addCylinderWidget()
```
    Adds a CylinderWidget with WIDGET_RADIUS_FACTOR radius symmetric about a line parallel to the parent mobility z axis but through the origin of SF_MOBILITY_FROM.
    
    If the z axis is as a translation DoF for the current joint type then the cylinder height and edge pattern track the mobility transform similar to the description in addPrismWidgets(int, float, float). Otherwise the cylinder height is given by CYLINDER_HEIGHT_FACTOR.
  - updateCylinderWidget
```
protected void updateCylinderWidget()
```
    Retrieves WN_JOINT_CYLINDER and calls updateCylinderWidget(CylinderWidget).
  - updateCylinderWidget
```
protected void updateCylinderWidget(vona.j3d.CylinderWidget w)
```
    Sets the extents of w along the z axis, and the edge pattern of w depending on the current z translation limits, if any. See addCylinderWidget() for details.
  - addSectorWidgets
```
protected vona.j3d.SectorWidget addSectorWidgets(float alpha)
```
    Adds a SectorWidget in the XY plane of SF_MOBILITY_TO centered on a line parallel to the Z axis but through the origin of SF_MOBILITY_FROM, with inner radius SECTOR_OFFSET_FACTOR and width SECTOR_WIDTH_FACTOR.
    
    The Z axis must be a rotation DoF.
    
    A second SectorWidget is also added with the same geometry but showing only its end edges. This gives independent control of the end edge pattern.
    
    If limits are set for Z rotation then the sector ends are aligned with those limits and are solid. Otherwise the ends endcaps track the mobility rotation and are broken.
  - updateSectorWidgets
```
protected void updateSectorWidgets()
```
    Retrieves WN_JOINT_SECTOR and WN_JOINT_SECTOR_ENDS and calls updateSectorWidgets(SectorWidget, SectorWidget).
  - updateSectorWidgets
```
protected void updateSectorWidgets(vona.j3d.SectorWidget w,
                       vona.j3d.SectorWidget ew)
```
    Sets the lengths and angles of w and ew, their translation in SF_MOBILITY_TO, and the edge pattern of ew depending on the current Z axis rotation limits, if any. See addSectorWidgets(float) for details.
  - addSegmentWidget
```
protected vona.j3d.SegmentWidget addSegmentWidget(int axis,
                                      float offsetFactor)
```
    Adds a Joint.SliderSegmentWidget on the indicated axis of SF_MOBILITY_FROM, starting at offsetFactor and ending at (offsetFactor+SEGMENT_LENGTH_FACTOR).
  - updateSegmentWidget
```
protected void updateSegmentWidget()
```
    Retrieves WN_JOINT_SEGMENT and calls updateSliderWidget(vona.j3d.EdgedFacetedWidget).
  - updateSliderWidget
```
protected void updateSliderWidget(vona.j3d.EdgedFacetedWidget w)
```
    sets color depending on whether the joint is locked
  - updateSliderWidget
```
protected void updateSliderWidget(vona.j3d.CurveWidget w)
```
    sets color depending on whether the joint is locked
  - addPrismWidgets
```
protected vona.j3d.PrismWidget addPrismWidgets(int axis,
                                   float alpha,
                                   float extraMargin)
```
    Adds a PrismWidget with a square WIDGET_WIDTH_FACTOR profile symmetric about axis in SF_MOBILITY_TO.
    
    A second PrismWidget is also added with the same geometry but showing only its (radial) endcap edges. This gives independent control of the endcap edge pattern.
    
    This can only be called for joints whose type defines axis as a translation DoF. If limits are set for this DoF then the prism endcaps are aligned with those limits and have solid edges. Otherwise the prism endcaps track the mobility translation in axis and have broken edges.
  - updatePrismWidgets
```
protected void updatePrismWidgets(int axis,
                      float extraMargin)
```
    Retrieves WN_JOINT_PRISM and WN_JOINT_PRISM_ENDS and calls updatePrismWidgets(PrismWidget, PrismWidget, int, float).
  - updatePrismWidgets
```
protected void updatePrismWidgets(vona.j3d.PrismWidget w,
                      vona.j3d.PrismWidget cw,
                      int axis,
                      float extraMargin)
```
    Sets the extents of w and cw along axis, and the edge pattern of cw depending on the current limits for axis, if any. See addPrismWidgets(int, float, float) for details.
  - addSquareWidget
```
protected vona.j3d.RectangleWidget addSquareWidget()
```
    Adds a RectangleWidget with WIDGET_WIDTH_FACTOR width and height in the XY plane, axis aligned, symmetric about the Z axis in SF_MOBILITY_FROM.
  - updateSquareWidget
```
protected void updateSquareWidget()
```
    Retrieves WN_JOINT_SQUARE and calls updateSliderWidget(vona.j3d.EdgedFacetedWidget).
  - addCircleWidget
```
protected vona.j3d.CircleWidget addCircleWidget()
```
    Adds a CircleWidget with WIDGET_RADIUS_FACTOR radius in the XY plane, symmetric about the Z axis in SF_MOBILITY_FROM.
  - updateCircleWidget
```
protected void updateCircleWidget()
```
    Retrieves WN_JOINT_CIRCLE and calls updateSliderWidget(vona.j3d.EdgedFacetedWidget).
  - addSphereWidget
```
protected vona.j3d.SphereWidget addSphereWidget()
```
    Adds a SphereWidget with WIDGET_RADIUS_FACTOR radius at the origin in SF_MOBILITY_FROM.
  - updateSphereWidget
```
protected void updateSphereWidget()
```
    Retrieves WN_JOINT_SPHERE and calls updateSphereWidget().
  - updateSphereWidget
```
protected void updateSphereWidget(vona.j3d.SphereWidget w)
```
    updates widget rx
  - addRectangleWidgets
```
protected vona.j3d.RectangleWidget addRectangleWidgets(float extraMargin)
```
    Adds a RectangleWidget in the XY plane in SF_MOBILITY_TO.
    
    A second RectangleWidget is also added with the same geometry but showing only its Y-axis edges. This gives independent control of the X and Y axis edge patterns.
    
    This can only be called for joints whose type defines the X and Y axes as translation DoF. If limits are set for either DoF then the corresponding edges are aligned with those limits and are solid. Otherwise the edges the mobility translation in each axis, and are broken.
  - updateRectangleWidgets
```
protected void updateRectangleWidgets(float extraMargin)
```
    Retrieves WN_JOINT_RECTANGLE and WN_JOINT_RECTANGLE_Y_EDGES and calls updateRectangleWidgets(RectangleWidget, RectangleWidget, float).
  - updateRectangleWidgets
```
protected void updateRectangleWidgets(vona.j3d.RectangleWidget w,
                          vona.j3d.RectangleWidget yw,
                          float extraMargin)
```
    Sets the extents of w and yw, and the edge patterns depending on the current limits for the X and Y axes, if any. See addRectangleWidgets(float) for details.
  - hasSubFrame
```
public boolean hasSubFrame(java.lang.String frame)
```
    Check if the named subframe is present.
    
    Default impl just checks for LinkageNode.SF_CANONICAL.
    
    This impl checks all joint subframes.
    
    Overrides:
    
    hasSubFrame in class LinkageNode
  - dumpSubFrames
```
public void dumpSubFrames(java.io.PrintStream s)
```
    Dump all available subframes.
    
    Default impl just dumps LinkageNode.SF_CANONICAL.
    
    This impl adds all joint subframes.
    
    Overrides:
    
    dumpSubFrames in class LinkageNode
  - isInternalFrame
```
public boolean isInternalFrame(java.lang.String frame)
```
    Check if frame is an internal (i.e. non-user) subframe.
    
    Default impl checks LinkageNode.SF_CANONICAL.
    
    This impl extends superclass to also check JOINT_SUBFRAMES.
    
    Overrides:
    
    isInternalFrame in class LinkageNode

Class Joint

TBD

Nested Class Summary

Nested classes/interfaces inherited from class msim.model.LinkageNode

Field Summary

Fields inherited from class msim.model.LinkageNode

Constructor Summary

Method Summary

Methods inherited from class msim.model.LinkageNode

Methods inherited from class java.lang.Object

Field Detail

cvsid

FMT_WIDTH

FMT

FMT_S

FMT3

FMT4

FMT6

FMT3_S

FMT4_S

FMT6_S

WP_JOINT

WP_ROUTE

SF_CHILD

SF_CHILD_MOBILITY

SF_PARENT_MOBILITY

SF_PARENT

SF_MOBILITY_FROM

SF_MOBILITY_TO

JOINT_SUBFRAMES

WIDGET_MARGIN

SECTOR_MARGIN

SEGMENT_OFFSET_FACTOR

SEGMENT_LENGTH_FACTOR

SECTOR_OFFSET_FACTOR

SECTOR_WIDTH_FACTOR

WIDGET_WIDTH_FACTOR

REVOLUTE_SECTOR_ALPHA

SLIDER_PRISM_ALPHA

PLANAR_RECTANGLE_ALPHA

LIMITED_EDGE_PATTERN

UNLIMITED_EDGE_PATTERN

LIMITED_EDGE_WIDTH

UNLIMITED_EDGE_WIDTH

SLIDER_EDGE_WIDTH

CYLINDER_HEIGHT_FACTOR

AXES_RADIUS_FACTOR

WIDGET_RADIUS_FACTOR

WIDGET_NUM_SECTORS

ROUTE_TANGENT_FACTOR

DEGENERATE_ROUTE_TANGENT_FACTOR

ROUTE_LINE_WIDTH

NUM_ROUTE_SEGMENTS

CONE_RADIUS_FACTOR

CONE_HEIGHT_FACTOR

NUM_CONE_SECTORS

DEGENERATE_ROUTE_TOL

BROKEN_TOL

JW_COLOR_SCHEME

TREE_ROUTE_COLOR_SCHEME

CLOSURE_ROUTE_COLOR_SCHEME

MOBILITY_ERROR_ROUTE_COLOR

JW_AXES

JW_LABEL

JW_ROUTE

JW_ROUTE_CONE

JW_MOBILITY_SURFACE

JW_SLIDER_SURFACE

JW_MOBILITY_SLIDER

WN_CHILD_MOBILITY_AXES

WN_PARENT_MOBILITY_AXES

WN_C_TO_M_ROUTE

WN_MOBILITY_ROUTE

WN_M_TO_P_ROUTE

WN_ROUTE_CONE_SUFFIX

WN_JOINT_LABEL

WN_JOINT_CYLINDER

WN_JOINT_SECTOR

WN_JOINT_SECTOR_ENDS

WN_JOINT_SEGMENT