artisynth.core.femmodels

Class SkinMeshBody

java.lang.Object

artisynth.core.modelbase.ModelComponentBase

artisynth.core.modelbase.RenderableComponentBase

artisynth.core.mechmodels.MeshComponent

artisynth.core.mechmodels.DynamicMeshComponent

artisynth.core.mechmodels.SkinMeshBase

artisynth.core.femmodels.SkinMeshBody

All Implemented Interfaces:

Collidable, CollidableBody, HasSlaveObjects, HasSurfaceMesh, PointAttachable, ComponentChangeListener, CompositeComponent, IndexedComponentList, ModelComponent, PostScannable, RenderableComponent, TransformableGeometry, ScalableUnits, java.lang.Cloneable, HasProperties, HierarchyNode, HasRenderProps, IsRenderable, IsSelectable, Renderable, Scannable

public class SkinMeshBody
extends SkinMeshBase
implements CollidableBody, PointAttachable

A MeshComponent that supports "skinning", in which the position of each mesh vertex is controlled by the configuration of one or more referenced master bodies}. Master bodies may currently include Frames and FEM models.

Each vertex is connected internally to the master bodies by a PointSkinAttachment, which contains a weighted PointSkinAttachment.SkinConnection to each body. The connection weights are computed based on the distance from the vertex to each body, and sum to one. All connections collectively determine the vertex position as the master bodies move and/or deform. A typical procedure for creating a SkinMeshBody in code is as follows:

    // create the body with an underlying mesh:
    SkinMeshBody skinMesh = new SkinMeshBody(mesh);

    // add the master body references:
    skinMesh.addMasterBody (rigidBody1);
    skinMesh.addMasterBody (rigidBody2);
    skinMesh.addMasterBody (femModel1);

    // compute the weighted connections for each vertex:
    skinMesh.computeAllVertexConnections();
 

By default, computeAllVertexConnections() uses an inverse square distance weighting scheme to determine the connection weights. Applications may determine the connection weights in other ways, either by specifying a different weighting function or by specifying them explicitly. Applications can also add point-based markers or create point-based attachments for a {\tt SkinMeshBody}.

For full details, see the Chapter ``Skinning'' in the ArtiSynth Modeling Guide.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	SkinMeshBody.BodyInfo Base class for information about bodies (e.g., Frames or FemNodels) used to control the skinning.
static class	SkinMeshBody.ElementRotationData Contains information about the rotation of a FEM element, which is needed when connecting a point or vertex to an FEM model using an ElementConnection.
static class	SkinMeshBody.FemConnectionType Decsribes the connection type used for FEM bodies.
static class	SkinMeshBody.FemModelInfo Contains information for each FemModel controlling this SkinMeshBody.
static class	SkinMeshBody.FrameBlending Characterizes the blend mechanism used for the frame-based portion of the skinning.
static class	SkinMeshBody.FrameInfo Contains information for each frame controlling this SkinMeshBody.
static class	SkinMeshBody.NearestPoint Contains information about the nearest point on a master body to a another point or mesh vertex.

Nested classes/interfaces inherited from interface artisynth.core.mechmodels.Collidable

Collidable.Collidability, Collidable.Group

Nested classes/interfaces inherited from interface artisynth.core.modelbase.ModelComponent

ModelComponent.NavpanelVisibility

Nested classes/interfaces inherited from interface artisynth.core.modelbase.CompositeComponent

CompositeComponent.NavpanelDisplay

Field Summary

Fields

Modifier and Type	Field and Description
static boolean	DEFAULT_ATTACH_POINTS_TO_MESH
static double	DEFAULT_DQ_BLEND_TOLERANCE
static int	DEFAULT_DQ_MAX_BLEND_STEPS
static SkinMeshBody.FemConnectionType	DEFAULT_FEM_CONNECTION_TYPE
static SkinMeshBody.FrameBlending	DEFAULT_FRAME_BLENDING
static PropertyList	myProps

Fields inherited from class artisynth.core.mechmodels.MeshComponent

DEFAULT_COLOR_INTERPOLATION, DEFAULT_SELECTABLE, DEFAULT_VERTEX_COLOR_MIXING

Fields inherited from class artisynth.core.modelbase.ModelComponentBase

enforceUniqueCompositeNames, enforceUniqueNames, myNumber, NULL_OBJ, useCompactPathNames

Fields inherited from interface artisynth.core.mechmodels.Collidable

All, AllBodies, Deformable, Rigid, Self

Fields inherited from interface artisynth.core.modelbase.TransformableGeometry

TG_ARTICULATED, TG_DRAGGER, TG_PRESERVE_ORIENTATION, TG_SIMULATING

Fields inherited from interface maspack.render.IsRenderable

TRANSPARENT, TWO_DIMENSIONAL

Constructor Summary

Constructors

Constructor and Description
SkinMeshBody() Creates an empty SkinMeshBody with no mesh.
SkinMeshBody(MeshBase mesh) Creates a SkinMeshBody with a specified mesh.
SkinMeshBody(java.lang.String name, MeshBase mesh) Creates a SkinMeshBody with a specified name and mesh.

Method Summary

Modifier and Type	Method and Description
void	addFemModel(FemModel3d fem) Deprecated. Use addMasterBody(artisynth.core.modelbase.ModelComponent) instead
void	addFrame(Frame frame) Deprecated. Use addMasterBody(artisynth.core.modelbase.ModelComponent) instead
SkinMarker	addMarker(Point3d pos) Creates and adds a marker to this SkinMeshBody.
SkinMarker	addMarker(java.lang.String name, Point3d pos) Creates and adds a marker to this SkinMeshBody.
SkinMarker	addMarker(java.lang.String name, Point3d pos, VectorNd weights) Creates and adds a marker to this SkinMeshBody.
void	addMasterBody(ModelComponent body) Adds a master body with this SkinMeshBody so that it can be used for skinning control.
SkinMarker	addMeshMarker(Point3d pos) Creates and adds a marker to the nearest mesh feature of this skin body.
SkinMarker	addMeshMarker(java.lang.String name, Point3d pos) Creates and adds a marker to the nearest mesh feature of this skin body.
boolean	allowCollision(ContactPoint cpnt, Collidable other, java.util.Set<Vertex3d> attachedVertices) Returns true if a collision between this Collidable and other should be allowed for the contact point cpnt.
void	clearMarkers() Removes all markers from this SkinMeshBody.
void	clearVertexConnections(int vidx) Clears master body connections for a specified vertex of this SkinMeshBody's mesh.
void	collectVertexMasters(java.util.List<ContactMaster> mlist, Vertex3d vtx) Collects the contact masters for a particular mesh vertex.
void	computeAllVertexConnections() Computes master body connections for every vertex of this SkinMeshBody's mesh.
void	computeVertexConnections(int vidx, VectorNd weights) Computes master body connections for a specified vertex of this SkinMeshBody's mesh.
void	computeWeights() Deprecated. Use computeAllVertexConnections() instead.
void	connectToHierarchy(CompositeComponent hcomp) Called by the system after this component, or an ancestor of this component, is added to the component hierarchy (i.e., added as a child of another CompositeComponent).
boolean	containsContactMaster(CollidableDynamicComponent comp) Returns true if this Collidable contains a specified contact master component.
PointSkinAttachment	createPointAttachment(Point pnt) Creates an attachment between a Point and this skin body.
PointSkinAttachment	createPointAttachment(Point pnt, VectorNd weights) Creates an attachment between a Point and the master bodies of this SkinMeshBody.
PointSkinAttachment	createPointMeshAttachment(Point pnt) Creates an attachment between a Point and the nearest mesh feature of this skin mesh body.
void	disconnectFromHierarchy(CompositeComponent hcomp) Called by the system after this component, or an ancestor of this component, is removed from the component hierarchy (i.e., removed as a child of its parent).
java.util.List<SkinMeshBody.BodyInfo>	getAllMasterBodyInfo() Returns the information structures of all master bodies that are currently registered with this SkinMeshBody.
PropertyList	getAllPropertyInfo() Returns a list giving static information about all properties exported by this object.
void	getAttachments(java.util.List<DynamicAttachment> list, int level)
boolean	getAttachPointsToMesh() Queries whether the point attachments created by createPointAttachment(Point) should connect directly to the skin body's mesh.
RigidTransform3d	getBasePose(Frame frame) Queries the base pose of a Frame based master body.
Collidable.Collidability	getCollidable() Returns the Collidable.Collidability of this Collidable.
Collidable	getCollidableAncestor() Returns the most immediate Collidable ancestor of this Collidable, if any.
int	getCollidableIndex()
PolygonalMesh	getCollisionMesh() Returns the mesh that should be used for computing collisions, or null if there is no such mesh.
DistanceGridComp	getDistanceGridComp() Returns a DistanceGridComp object that in turn contains a signed distance grid that can be used with a SignedDistanceCollider, or null if this Collidable does not support a signed distance grid (i.e., if CollidableBody.hasDistanceGrid() returns false).
double	getDQBlendTolerance() Queries the tolerance used for iterative dual-quaternion frame blending.
int	getDQMaxBlendSteps() Queries the maximum number of steps used for iterative dual-quaternion frame blending.
SkinMeshBody.FemConnectionType	getFemConnectionType() Queries the connection type to be used when creating subsequent connections to FEM master bodies.
SkinMeshBody.FrameBlending	getFrameBlending() Queries the blend type for that part of the skinning that depends on frames.
double	getMass() Returns an estimate of the mass of this SkinMeshBody (as determined by the underlying master bodies) for purposes of handling collisions.
ModelComponent	getMasterBody(int idx) Gets the idx-th master body registered with this SkinMeshBody.
void	getSoftReferences(java.util.List<ModelComponent> refs) Appends all soft references for this component to a list.
PointSkinAttachment	getVertexAttachment(int idx) Returns the attachment associated with the idx-th mesh vertex of this SkinMeshBody.
PointSkinAttachment	getVertexAttachment(Vertex3d vtx) Returns the attachment associated with a specific mesh vertex of this SkinMeshBody.
Point3d	getVertexBasePosition(int idx) Returns the base (i.e., initial) position for a specified vertex in this SkinMeshBody.
double	getVertexBaseWeight(int idx) Returns the base weight for a specified vertex in this SkinMeshBody.
SkinWeightingFunction	getWeightingFunction() Returns the weighting function used to compute connections.
boolean	hasDistanceGrid() Returns true if this Collidable supports a signed distance grid that can be used with a SignedDistanceCollider.
boolean	hasInvariantMasters() Queries whether or not the contact masters for a particular collision point are invariant across all contacts.
boolean	hasMasterBody(ModelComponent body) Returns true is a specified master body is currently registered with this SkinMeshBody.
boolean	isCompound() Queries whether or not this collidable has sub-collidables.
boolean	isDeformable() Returns true if this collidable is deformable.
PointList<SkinMarker>	markers() Returns the list of markers associated with this SkinMeshBody.
int	numMasterBodies() Returns the number of master bodies currently registered with this SkinMeshBody.
int	numVertexAttachments() Returns the number of vertex attachments in this SkinMeshBody.
void	prerender(RenderList list) Called prior to rendering to allow this object to update the internal state required for rendering (such as by caching rendering coordinates).
boolean	removeMarker(SkinMarker mkr) Removes a marker from this SkinMeshBody.
boolean	removeMasterBody(ModelComponent body) Removes a master body from this SkinMeshBody.
void	setAttachPointsToMesh(boolean enable) Sets whether the point attachments created by createPointAttachment(Point) should connect directly to the skin body's mesh.
void	setBasePose(Frame frame, RigidTransform3d TBW0) Sets the base pose of a Frame based master body.
void	setCollidable(Collidable.Collidability c)
void	setCollidableIndex(int idx)
void	setDQBlendTolerance(double tol) Sets the tolerance used for iterative dual-quaternion frame blending.
void	setDQMaxBlendSteps(int max) Sets the maximum number of steps used for iterative dual-quaternion frame blending.
void	setFemConnectionType(SkinMeshBody.FemConnectionType type) Sets the connection type to be used when creating subsequent connections to FEM master bodies.
void	setFrameBlending(SkinMeshBody.FrameBlending type) Sets the blend type for that part of the skinning that depends on frames.
void	setGaussianWeighting(double sigma) Sets the weighting function to be used in computing connections to an inverse square weighting implemented by InverseSquareWeighting.
void	setInverseSquareWeighting() Sets the weighting function to be used in computing connections to an inverse square weighting implemented by InverseSquareWeighting.
void	setMesh(MeshBase mesh) Sets the mesh associated with the this SkinMeshBody.
void	setVertexBasePosition(int idx, Vector3d pos) Sets the base (i.e., initial) position for a specified vertex in this SkinMeshBody.
void	setVertexBaseWeight(int idx, double w, boolean normalize) Sets the base weight for a specified vertex in this SkinMeshBody.
void	setWeightingFunction(SkinWeightingFunction fxn) Sets the weighting function to be used in computing connections in subsequent calls to the methods computeAllVertexConnections(), computeVertexConnections(int, maspack.matrix.VectorNd), addMarker(Point3d), createPointAttachment(Point), etc.
void	smoothWeights() Smooths vertex connection weights by looking at neighbouring vertices.
void	smoothWeights(Function1x1 weightFunction, int networkDist) Smooths vertex connection weights according to a function of distance.
void	smoothWeights(int networkDist) Smooths vertex connection weights according to a function of distance.
void	transformGeometry(GeometryTransformer gtr, TransformGeometryContext context, int flags) Transforms the geometry of this component, using the geometry transformer gtr to transform its individual attributes.
void	updateReferences(boolean undo, java.util.Deque<java.lang.Object> undoInfo) May be called by the system if any of the soft references for this component are removed from the the component hierarchy.
void	updateSlavePos() Updates the mesh vertices to reflect the current position of the attached Frames, FemModels, and points.

Methods inherited from class artisynth.core.mechmodels.SkinMeshBase

componentChanged, copy, findComponent, get, get, getByNumber, getChildren, getNavpanelDisplay, getNavpanelVisibility, getNumberLimit, getSurfaceMesh, getSurfaceMeshes, hasChildren, hierarchyContainsReferences, indexOf, numComponents, numSurfaceMeshes, postscan, scaleDistance, scan, setDisplayMode, setNavpanelDisplay, updateNameMap, updateSlaveVel

Methods inherited from class artisynth.core.mechmodels.MeshComponent

addTransformableDependencies, createSurfaceMeshArray, getColorInterpolation, getFileName, getFileTransform, getMesh, getMeshToWorld, getSurfaceMeshes, getVertex, getVertexColorMixing, isFileTransformRigid, isMeshModified, isMeshPolygonal, isMeshTriangular, isSelectable, numSurfaceMeshes, numVertices, prerenderMesh, render, render, scaleMass, setColorInterpolation, setFileName, setFileTransform, setMesh, setMesh, setMeshToWorld, setSelectable, setVertexColorMixing, transformGeometry, updateBounds, updatePosition

Methods inherited from class artisynth.core.modelbase.RenderableComponentBase

createRenderProps, defaultRenderPropsAreNull, getRenderHints, getRenderProps, getSelection, isVisible, numSelectionQueriesNeeded, setRenderProps, setVisible, updateRenderProps

Methods inherited from class artisynth.core.modelbase.ModelComponentBase

checkFlag, checkName, checkNameUniqueness, clearFlag, clone, createTempFlag, getGrandParent, getHardReferences, getName, getNameRange, getNavpanelVisibility, getNumber, getParent, getProperty, hasState, isFixed, isMarked, isScanning, isSelected, isWritable, makeValidName, makeValidName, notifyParentOfChange, printReferences, recursivelyContained, recursivelyContains, removeTempFlag, setFixed, setFlag, setMarked, setName, setNavpanelVisibility, setNavpanelVisibility, setNumber, setParent, setScanning, setSelected, setWritable, write

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface artisynth.core.modelbase.ModelComponent

getHardReferences, getName, getNavpanelVisibility, getNumber, getParent, hasState, isFixed, isMarked, isSelected, notifyParentOfChange, scan, setFixed, setMarked, setName, setNumber, setParent, setSelected, setWritable

Methods inherited from interface maspack.properties.HasProperties

getProperty

Methods inherited from interface maspack.properties.HierarchyNode

getChildren, hasChildren

Methods inherited from interface artisynth.core.modelbase.PostScannable

postscan

Methods inherited from interface maspack.util.Scannable

isWritable, write

Field Detail

DEFAULT_FRAME_BLENDING

public static SkinMeshBody.FrameBlending DEFAULT_FRAME_BLENDING

DEFAULT_DQ_BLEND_TOLERANCE

public static double DEFAULT_DQ_BLEND_TOLERANCE

DEFAULT_DQ_MAX_BLEND_STEPS

public static int DEFAULT_DQ_MAX_BLEND_STEPS

DEFAULT_ATTACH_POINTS_TO_MESH

public static boolean DEFAULT_ATTACH_POINTS_TO_MESH

DEFAULT_FEM_CONNECTION_TYPE

public static final SkinMeshBody.FemConnectionType DEFAULT_FEM_CONNECTION_TYPE

myProps

public static PropertyList myProps

Constructor Detail

SkinMeshBody

public SkinMeshBody()

Creates an empty SkinMeshBody with no mesh.

SkinMeshBody

public SkinMeshBody(MeshBase mesh)

Creates a SkinMeshBody with a specified mesh.

Parameters:

mesh - mesh to be associated with the body

SkinMeshBody

public SkinMeshBody(java.lang.String name,
                    MeshBase mesh)

Creates a SkinMeshBody with a specified name and mesh.

Parameters:

name - name of the body

mesh - mesh to be associated with the body

Method Detail

getAllPropertyInfo

public PropertyList getAllPropertyInfo()

Returns a list giving static information about all properties exported by this object.

Specified by:

getAllPropertyInfo in interface HasProperties

Overrides:

getAllPropertyInfo in class SkinMeshBase

Returns:

static information for all exported properties

setFrameBlending

public void setFrameBlending(SkinMeshBody.FrameBlending type)

Sets the blend type for that part of the skinning that depends on frames.

Parameters:

type - frame blending type

getFrameBlending

public SkinMeshBody.FrameBlending getFrameBlending()

Queries the blend type for that part of the skinning that depends on frames.

Returns:

current frame blending type

getCollidable

public Collidable.Collidability getCollidable()

Returns the Collidable.Collidability of this Collidable. This provides control over whether external and/or internal collisions are enabled for this Collidable. This setting takes precedence over default and explicitly requested collision behaviors.

Note that for collisions to actually occur, they still need to be enabled through either a default or explicit collision behavior in the MechModel.

Specified by:

getCollidable in interface Collidable

Returns:

Collidability of this collidable.

setCollidable

public void setCollidable(Collidable.Collidability c)

getWeightingFunction

public SkinWeightingFunction getWeightingFunction()

Returns the weighting function used to compute connections.

Returns:

current weighting function

See Also:

setWeightingFunction(artisynth.core.femmodels.SkinWeightingFunction)

setWeightingFunction

public void setWeightingFunction(SkinWeightingFunction fxn)

Sets the weighting function to be used in computing connections in subsequent calls to the methods computeAllVertexConnections(), computeVertexConnections(int, maspack.matrix.VectorNd), addMarker(Point3d), createPointAttachment(Point), etc. Current vertex and marker connections will remain unchanged.

Parameters:

fxn - new weighting function.

setInverseSquareWeighting

public void setInverseSquareWeighting()

Sets the weighting function to be used in computing connections to an inverse square weighting implemented by InverseSquareWeighting. This is equivalent to calling

    setWeightingFunction (new InverseSquareWeighting())
 

setGaussianWeighting

public void setGaussianWeighting(double sigma)

Sets the weighting function to be used in computing connections to an inverse square weighting implemented by InverseSquareWeighting. This is equivalent to calling

    setWeightingFunction (new InverseSquareWeighting())
 

getDQBlendTolerance

public double getDQBlendTolerance()

Queries the tolerance used for iterative dual-quaternion frame blending.

Returns:

iterative dual-quaternion blending tolerance

setDQBlendTolerance

public void setDQBlendTolerance(double tol)

Sets the tolerance used for iterative dual-quaternion frame blending.

Parameters:

tol - new blending tolerance

getDQMaxBlendSteps

public int getDQMaxBlendSteps()

Queries the maximum number of steps used for iterative dual-quaternion frame blending.

Returns:

max dual-quaternion blending steps

setDQMaxBlendSteps

public void setDQMaxBlendSteps(int max)

Sets the maximum number of steps used for iterative dual-quaternion frame blending.

Parameters:

max - maximum number of blending steps

getAttachPointsToMesh

public boolean getAttachPointsToMesh()

Queries whether the point attachments created by createPointAttachment(Point) should connect directly to the skin body's mesh. See setAttachPointsToMesh for details.

Returns:

if true, point attachments created by createPointAttachment(Point) should connect to skin body's mesh

See Also:

setAttachPointsToMesh(boolean)

setAttachPointsToMesh

public void setAttachPointsToMesh(boolean enable)

Sets whether the point attachments created by createPointAttachment(Point) should connect directly to the skin body's mesh. If this is true, and the body's mesh is both an instance of PolygonalMesh and triangular, then the point attachment is created using createPointMeshAttachment(Point). Otherwise, a direct connection to the master bodies is created using createPointAttachment(Point,VectorNd).

Parameters:

enable - if true, subsequent point attachments created by createPointAttachment(Point) should connect to skin body's mesh

See Also:

getAttachPointsToMesh()

setMesh

public void setMesh(MeshBase mesh)

Sets the mesh associated with the this SkinMeshBody. Connections between the vertices and master bodies will not be generated; this must be done subsequently by calling computeAllVertexConnections() or computeVertexConnections(int,VectorNd).

Overrides:

setMesh in class MeshComponent

Parameters:

mesh - new mesh to be associated with this body

getVertexBasePosition

public Point3d getVertexBasePosition(int idx)

Returns the base (i.e., initial) position for a specified vertex in this SkinMeshBody.

Parameters:

idx - index of the vertex. Must be less than numVertexAttachments().

setVertexBasePosition

public void setVertexBasePosition(int idx,
                                  Vector3d pos)

Sets the base (i.e., initial) position for a specified vertex in this SkinMeshBody.

Parameters:

idx - index of the vertex. Must be less than numVertexAttachments().

pos - new base position

getVertexBaseWeight

public double getVertexBaseWeight(int idx)

Returns the base weight for a specified vertex in this SkinMeshBody.

Parameters:

idx - index of the vertex. Must be less than numVertexAttachments().

setVertexBaseWeight

public void setVertexBaseWeight(int idx,
                                double w,
                                boolean normalize)

Sets the base weight for a specified vertex in this SkinMeshBody.

Parameters:

idx - index of the vertex. Must be less than numVertexAttachments().

w - new base weight to set

normalize - if true, and the other connection weights sum to a non-zero value, scales the other connection weights so that the total weight sum remains unchanged.

numVertexAttachments

public int numVertexAttachments()

Returns the number of vertex attachments in this SkinMeshBody. This will equal the same number returned by MeshComponent.numVertices().

Specified by:

numVertexAttachments in class SkinMeshBase

getVertexAttachment

public PointSkinAttachment getVertexAttachment(int idx)

Returns the attachment associated with the idx-th mesh vertex of this SkinMeshBody.

Specified by:

getVertexAttachment in class SkinMeshBase

Parameters:

idx - index of the vertex for which the attachment is desired. Must be less that numVertexAttachments().

Returns:

PointAttachment structure

getVertexAttachment

public PointSkinAttachment getVertexAttachment(Vertex3d vtx)

Returns the attachment associated with a specific mesh vertex of this SkinMeshBody.

Specified by:

getVertexAttachment in class DynamicMeshComponent

Parameters:

vtx - vertex for which the attachment is desired.

Returns:

PointAttachment structure

getAttachments

public void getAttachments(java.util.List<DynamicAttachment> list,
                           int level)

addMarker

public SkinMarker addMarker(Point3d pos)

Creates and adds a marker to this SkinMeshBody. This method functions identically to addMarker(String,Point3d), with name equal to null.

Parameters:

pos - initial marker position

Returns:

the created marker

addMarker

public SkinMarker addMarker(java.lang.String name,
                            Point3d pos)

Creates and adds a marker to this SkinMeshBody. The marker's connections are based on its initial position (described by pos) and the current master body configurations, with the connection weights for each master body determined by the skin weighting function (as returned by getWeightingFunction()).

Parameters:

name - name of the marker

pos - initial marker position

Returns:

the created marker

addMarker

public SkinMarker addMarker(java.lang.String name,
                            Point3d pos,
                            VectorNd weights)

Creates and adds a marker to this SkinMeshBody. The marker's connections are based on its initial position (described by pos) and the current master body configurations, with the connection weights for each master body specified by weights.

The size of weights must be >= numMasterBodies(). If it is >= numMasterBodies()+1, the additional value specifies the marker attachment's base weight.

Parameters:

name - name of the marker

pos - initial marker position

weights - connection weights

Returns:

the created marker

addMeshMarker

public SkinMarker addMeshMarker(Point3d pos)

Creates and adds a marker to the nearest mesh feature of this skin body. functions identically to addMeshMarker(String,Point3d), with name equal to null.

Parameters:

pos - requested initial marker position

Returns:

the created marker

addMeshMarker

public SkinMarker addMeshMarker(java.lang.String name,
                                Point3d pos)

Creates and adds a marker to the nearest mesh feature of this skin body. The mesh must be both an instance of PolygonalMesh and triangular. The requested marker position pos is then projected onto the nearest mesh feature (e.g., a face for a PolygonalMesh or a line segment for a PolylineMesh), and the master body connections are formed by a linear combination of the connections of the nearest feature vertices, based on the barycentric coordinates of the projected point position.

Attaching markers to the mesh entails a greater computational cost but ensures that the marker will remain connected to the mesh in the same relative position. If the vertex connections are subsequently changed, such as through a call to computeAllVertexConnections(), the marker will no longer follow the mesh position.

Parameters:

name - name of the marker

pos - requested initial marker position

Returns:

the created marker

removeMarker

public boolean removeMarker(SkinMarker mkr)

Removes a marker from this SkinMeshBody.

Parameters:

mkr - marker to remove

Returns:

true if the marker was present and was removed

clearMarkers

public void clearMarkers()

Removes all markers from this SkinMeshBody.

markers

public PointList<SkinMarker> markers()

Returns the list of markers associated with this SkinMeshBody.

Returns:

marker list

addFrame

public void addFrame(Frame frame)

Deprecated. Use addMasterBody(artisynth.core.modelbase.ModelComponent) instead

removeMasterBody

public boolean removeMasterBody(ModelComponent body)

Removes a master body from this SkinMeshBody. This is a special purpose method and does not update any existing connections to reflect the removed frame. Connections should therefore be computed (or recomputed) after this method has been called.

Parameters:

body - master body to be removed

Returns:

true if body found and removed, false otherwise

hasMasterBody

public boolean hasMasterBody(ModelComponent body)

Returns true is a specified master body is currently registered with this SkinMeshBody.

Parameters:

body - body to be queried

getMasterBody

public ModelComponent getMasterBody(int idx)

Gets the idx-th master body registered with this SkinMeshBody.

Parameters:

idx - index of the desired body; must be between 0 and the number returned by numMasterBodies() numMasterBodies().

Returns:

idx-th master body

numMasterBodies

public int numMasterBodies()

Returns the number of master bodies currently registered with this SkinMeshBody.

addMasterBody

public void addMasterBody(ModelComponent body)

Adds a master body with this SkinMeshBody so that it can be used for skinning control. At present, master bodies are restricted to instances of Frame and FemModel3d.

Parameters:

body - master body to be registered

getBasePose

public RigidTransform3d getBasePose(Frame frame)

Queries the base pose of a Frame based master body.

Parameters:

frame - frame for which the base pose is requested

Returns:

base pose for frame

setBasePose

public void setBasePose(Frame frame,
                        RigidTransform3d TBW0)

Sets the base pose of a Frame based master body.

Parameters:

frame - frame for which the base pose is to be set

TBW0 - new base pose

getAllMasterBodyInfo

public java.util.List<SkinMeshBody.BodyInfo> getAllMasterBodyInfo()

Returns the information structures of all master bodies that are currently registered with this SkinMeshBody.

addFemModel

public void addFemModel(FemModel3d fem)

Deprecated. Use addMasterBody(artisynth.core.modelbase.ModelComponent) instead

computeWeights

public void computeWeights()

Deprecated. Use computeAllVertexConnections() instead.

computeAllVertexConnections

public void computeAllVertexConnections()

Computes master body connections for every vertex of this SkinMeshBody's mesh. The current vertex positions are used as initial positions, and the connection weights are determined by using the skin weighting function (as returned by getWeightingFunction()).

computeVertexConnections

public void computeVertexConnections(int vidx,
                                     VectorNd weights)

Computes master body connections for a specified vertex of this SkinMeshBody's mesh. The current vertex position is used as the initial position.

The connection weights for each master body can be specified by the optional argument weights. If weights is null, then the weights are determined by the skin weighting function (as returned by getWeightingFunction()). If non-null, the size of weights must be >= numMasterBodies(). If it is >= numMasterBodies()+1, the additional value specifies the vertex attachment's base weight.

Parameters:

vidx - index of the vertex for which connections are to be computed

weights - if non-null, specifies connection weights

clearVertexConnections

public void clearVertexConnections(int vidx)

Clears master body connections for a specified vertex of this SkinMeshBody's mesh. This means that the vertex position will remain fixed and will not move in response to the motion of any of the master bodies. The position at which the vertex will remain fixed is set to its current position.

Parameters:

vidx - index of the vertex for which connections are to be cleared `

smoothWeights

public void smoothWeights(Function1x1 weightFunction,
                          int networkDist)

Smooths vertex connection weights according to a function of distance. At present, this only smooths the weights associated with Frame connections. Results when the SkinMeshBody contains other types of attachment connections are undefined.

This method is experimental.

Parameters:

weightFunction - single-input single-output function of distance to use as weights

networkDist - number of paths to traverse to collect vertices

smoothWeights

public void smoothWeights(int networkDist)

Smooths vertex connection weights according to a function of distance. Identical to smoothWeights(Function1x1,int) with weightFunction set to a constant value of 1.

This method is experimental.

Parameters:

networkDist - number of paths to traverse to collect vertices

smoothWeights

public void smoothWeights()

Smooths vertex connection weights by looking at neighbouring vertices. Identical to smoothWeights(Function1x1,int) with weightFunction set to a constant value of 1 and networkDist set to 1.

This method is experimental.

updateSlavePos

public void updateSlavePos()

Updates the mesh vertices to reflect the current position of the attached Frames, FemModels, and points.

Specified by:

updateSlavePos in interface HasSlaveObjects

Overrides:

updateSlavePos in class SkinMeshBase

setFemConnectionType

public void setFemConnectionType(SkinMeshBody.FemConnectionType type)

Sets the connection type to be used when creating subsequent connections to FEM master bodies. The default is an element based connection (type SkinMeshBody.FemConnectionType.ELEMENT. The alternative is the legacy displacement based connection (type SkinMeshBody.FemConnectionType.DISPLACEMENT. This method is provided to allow applications to employ the legacy displacement connection type ( which works well only for FEM deformations that do not involve a large amount of rotation).

Changing the connection type will only affect connections that are created through subsequent calls to the methods computeAllVertexConnections(), computeVertexConnections(int, maspack.matrix.VectorNd), addMarker(Point3d), createPointAttachment(Point), etc.

Parameters:

type - new element connection type

getFemConnectionType

public SkinMeshBody.FemConnectionType getFemConnectionType()

Queries the connection type to be used when creating subsequent connections to FEM master bodies.

Returns:

element connection type

createPointAttachment

public PointSkinAttachment createPointAttachment(Point pnt)

Creates an attachment between a Point and this skin body. If getAttachPointsToMesh() returns true, and the body has a triangular mesh, then the point is connected to the mesh using createPointMeshAttachment(Point). Otherwise, the point is connected to the masters using a direct connection via createPointAttachment(Point,VectorNd).

Specified by:

createPointAttachment in interface PointAttachable

Parameters:

pnt - point to be attached

Returns:

attachment component

createPointMeshAttachment

public PointSkinAttachment createPointMeshAttachment(Point pnt)

Creates an attachment between a Point and the nearest mesh feature of this skin mesh body. The mesh must be both an instance of PolygonalMesh and triangular. The point to be attached is then projected onto the nearest mesh feature (e.g., a face for a PolygonalMesh or a line segment for a PolylineMesh), and the master body connections are formed by a linear combination of the connections of the nearest feature vertices, based on the barycentric coodinates of the projected point position.

Attaching points to the mesh entails a greater computational cost but ensures that the attached point will remain connected to the mesh in the same relative position. If the vertex connections are subsequently changed, such as through a call to computeAllVertexConnections(), the attached point will no longer follow the mesh position.

Parameters:

pnt - point to be attached

Returns:

attachment component

createPointAttachment

public PointSkinAttachment createPointAttachment(Point pnt,
                                                 VectorNd weights)

Creates an attachment between a Point and the master bodies of this SkinMeshBody. The connection weights for each master body are specified by weights.

The size of weights must be >= numMasterBodies(). If it is >= numMasterBodies()+1, the additional value specifies the attachment's base weight.

Parameters:

pnt - point to be attached

weights - connection weights

Returns:

attachment component

getCollisionMesh

public PolygonalMesh getCollisionMesh()

Returns the mesh that should be used for computing collisions, or null if there is no such mesh. If this method returns null, then no collisions will be performed for this collidable, regardless any default or explicit collision behaviors that have been arranged by the system.

Specified by:

getCollisionMesh in interface CollidableBody

Returns:

collision mesh for this collidable.

hasDistanceGrid

public boolean hasDistanceGrid()

Returns true if this Collidable supports a signed distance grid that can be used with a SignedDistanceCollider. At present, this will only be true for non-deformable bodies.

Specified by:

hasDistanceGrid in interface CollidableBody

Returns:

true if this Collidable supports a signed distance grid

getDistanceGridComp

public DistanceGridComp getDistanceGridComp()

Returns a DistanceGridComp object that in turn contains a signed distance grid that can be used with a SignedDistanceCollider, or null if this Collidable does not support a signed distance grid (i.e., if CollidableBody.hasDistanceGrid() returns false).

Specified by:

getDistanceGridComp in interface CollidableBody

getCollidableAncestor

public Collidable getCollidableAncestor()

Returns the most immediate Collidable ancestor of this Collidable, if any. Otherwise, return null.

Specified by:

getCollidableAncestor in interface Collidable

Returns:

immediate Collidable ancestor, or null.

isCompound

public boolean isCompound()

Queries whether or not this collidable has sub-collidables.

Specified by:

isCompound in interface Collidable

Returns:

true if this collidable has sub-collidables

isDeformable

public boolean isDeformable()

Returns true if this collidable is deformable. Whether or not a collidable is deformable determines how it responds to default collision behaviors involving deformable and rigid collidables. Also, self-collisions among sub-collidables of a collidable A are permitted only if A is deformable.

Specified by:

isDeformable in interface Collidable

Returns:

true if this collidable is deformable

getMass

public double getMass()

Returns an estimate of the mass of this SkinMeshBody (as determined by the underlying master bodies) for purposes of handling collisions.

Specified by:

getMass in interface CollidableBody

Returns:

estimated mass

collectVertexMasters

public void collectVertexMasters(java.util.List<ContactMaster> mlist,
                                 Vertex3d vtx)

Collects the contact masters for a particular mesh vertex. The masters should be appended to mlist. The vertex should be a vertex of the mesh returned by CollidableBody.getCollisionMesh().

If CollidableBody.hasInvariantMasters() returns true, then the contact masters will not depend on vtx.

Specified by:

collectVertexMasters in interface CollidableBody

Parameters:

mlist - collected master components

vtx - vertex for which the master components are requested

hasInvariantMasters

public boolean hasInvariantMasters()

Queries whether or not the contact masters for a particular collision point are invariant across all contacts. An example where they are is a rigid body, where the body is the (single) master regardless of the contacts. An example where they are not is a finite element model, where the nodes associated with each contacting vertex form the masters for that contact.

A collidable that has invariant contact masters typically has fewer dynamic degrees of freedom compared to one that does not.

Specified by:

hasInvariantMasters in interface CollidableBody

Returns:

true if contact masters are constant

containsContactMaster

public boolean containsContactMaster(CollidableDynamicComponent comp)

Returns true if this Collidable contains a specified contact master component.

Specified by:

containsContactMaster in interface CollidableBody

Parameters:

comp - component to test for

Returns:

true if comp is contained in this Collidable

allowCollision

public boolean allowCollision(ContactPoint cpnt,
                              Collidable other,
                              java.util.Set<Vertex3d> attachedVertices)

Returns true if a collision between this Collidable and other should be allowed for the contact point cpnt. In making this decision, this method may refer to attachedVertices, which supplies a list of vertices on this Collidable which are attached in some way to the other Collidable.

Specified by:

allowCollision in interface CollidableBody

Parameters:

cpnt - contact point being tested

other - opposing collidable

attachedVertices - list of vertices attached to other.

Returns:

true if the collision should be allowed

getCollidableIndex

public int getCollidableIndex()

Specified by:

getCollidableIndex in interface CollidableBody

setCollidableIndex

public void setCollidableIndex(int idx)

Specified by:

setCollidableIndex in interface CollidableBody

transformGeometry

public void transformGeometry(GeometryTransformer gtr,
                              TransformGeometryContext context,
                              int flags)

Transforms the geometry of this component, using the geometry transformer gtr to transform its individual attributes. The context argument supplies information about what other components are currently being transformed, and also allows the requesting of update actions to be performed after all transform called have completed. The context is also the usual entity that calls this method, from within its TransformGeometryContext.apply(maspack.geometry.GeometryTransformer, int) method. The argument flags provides flags to specify various conditions associated with the the transformation. At present, the available flags are TransformableGeometry.TG_SIMULATING and TransformableGeometry.TG_ARTICULATED.

This method is not usually called directly by applications. Instead, it is typically called from within the TransformGeometryContext.apply(maspack.geometry.GeometryTransformer, int) method of the context, which takes care of the various operations needed for a complete transform operation, including calling TransformableGeometry.addTransformableDependencies(artisynth.core.modelbase.TransformGeometryContext, int) to collect other components that should be transformed, calling TransformableGeometry.transformGeometry(maspack.matrix.AffineTransform3dBase) for each component, notifying component parents that the geometry has changed, and calling any requested TransformGeometryActions. More details are given in the documentation for TransformGeometryContext.apply(maspack.geometry.GeometryTransformer, int).

TransformGeometryContext provides a number of static convenience transform methods which take care of building the context and calling apply() for a specified set of components.

This method should not generally call transformGeometry() for its descendant components. Instead, descendants needing transformation should be specified by adding them to the context in the method TransformableGeometry.addTransformableDependencies(artisynth.core.modelbase.TransformGeometryContext, int).

Specified by:

transformGeometry in interface TransformableGeometry

Overrides:

transformGeometry in class SkinMeshBase

Parameters:

gtr - transformer implementing the transform

context - context information, including what other components are being transformed

flags - specifies conditions associated with the transformation

prerender

public void prerender(RenderList list)

Called prior to rendering to allow this object to update the internal state required for rendering (such as by caching rendering coordinates). The object may add internal objects to the list of objects being rendered, by calling

list.addIfVisible (obj);

for each of the objects in question.

Specified by:

prerender in interface IsRenderable

Overrides:

prerender in class MeshComponent

Parameters:

list - list of objects to be rendered

connectToHierarchy

public void connectToHierarchy(CompositeComponent hcomp)

Called by the system after this component, or an ancestor of this component, is added to the component hierarchy (i.e., added as a child of another CompositeComponent). This method is responsible for doing any required hierarchy-dependent initialization, including any updating of referenced components.

When this method is called, ModelComponent.getParent() will return the new parent component; the system will have set this beforehand.

Specified by:

connectToHierarchy in interface ModelComponent

Overrides:

connectToHierarchy in class ModelComponentBase

Parameters:

hcomp - hierarchy component to which this component, or its ancestor, was attached

disconnectFromHierarchy

public void disconnectFromHierarchy(CompositeComponent hcomp)

Called by the system after this component, or an ancestor of this component, is removed from the component hierarchy (i.e., removed as a child of its parent). This method is responsible for any required hierarchy-dependent deinitialization, including any updating of referenced components.

When this method is called, ModelComponent.getParent() will still return this original parent component; the system will set this to null after.

Specified by:

disconnectFromHierarchy in interface ModelComponent

Overrides:

disconnectFromHierarchy in class ModelComponentBase

Parameters:

hcomp - hierarchy component from which this component, or its ancestor, was detached

getSoftReferences

public void getSoftReferences(java.util.List<ModelComponent> refs)

Appends all soft references for this component to a list. References are other components, outside of this component's immediate ancestry, on which this component depends. For example, an ExcitationComponent may refer to one or more other ExcitationComponents to act as excitation sources. A soft reference is one which can be removed from the referring component. In particular, if any soft references for a component are deleted, then that component's updateReferences() method will be called to update its internal reference information.

Specified by:

getSoftReferences in interface ModelComponent

Overrides:

getSoftReferences in class ModelComponentBase

Parameters:

refs - list to which soft references are appended

updateReferences

public void updateReferences(boolean undo,
                             java.util.Deque<java.lang.Object> undoInfo)

May be called by the system if any of the soft references for this component are removed from the the component hierarchy. If called with undo equal to false, this component should then examine its soft references and use ComponentUtils.areConnected() to determine which of them have been disconnected from the hierarchy. Disconnected references should be removed, and sufficient information should be appended to undoInfo to allow this update to be undone if this method is called later with undo equal to true. When undoing an update, the undo information should be removed from the front of undoInfo.

Specified by:

updateReferences in interface ModelComponent

Overrides:

updateReferences in class ModelComponentBase

Parameters:

undo - if true, indicates that the most recent reference update should be undone, using the supplied undo information.

undoInfo - if undo is false, should be used to store information allowing the reference update to be undone. Otherwise, if undo is true, then this supplied information to undo the most recent update.