Skip to content

HandFitPlugin

Hand plugin aligning node’s rig with keypoints

Universal plugin aligning node’s armature and the hand pose estimated by @geenee/bodyprocessors!HandProcessor. Basically, HandFitPlugin evaluates positions and rotations of armature bones based on detected keypoints, then applies these transforms to bones following the armature hierarchy. Plugin supports rigs compatible with Clo3D and Marvelous Designer avatars. This is the most common standard of rigs in cloth/apparel modeling software. Controlled scene node must contain an armature among its children nodes. Bones of armature must follow Clo3D naming convention and hierarchy.

new HandFitPlugin(): HandFitPlugin

Constructor

HandFitPlugin

HandPlugin.constructor

loaded: boolean

Loaded state

HandPlugin.loaded


protected optional node: TransformNode

Attached scene node


protected nodeOrigin: BoneTransform

Origin of node relative to the root bone


ordinal: number

Ordinal number

HandPlugin.ordinal


protected optional renderer: Renderer<HandResult>

Renderer loaded the plugin

HandPlugin.renderer


protected optional scene: Scene

Reference to a scene instance

HandPlugin.scene


protected optional skeleton: Skeleton

Reference to model’s skeleton


protected optional skeletonNodes: SkeletonNodes

Bones of the model’s rig


protected optional skeletonSizes: SkeletonSizes

Reference sizes of skeleton

dispose(): void

Dispose video plugin

void

HandPlugin.dispose


protected estimateBones(pose, handedness): object

Estimate bone positions and orientations

Using detected keypoints approximates bone transformations. Position of bone if defined by 3D point itself, bone length is the distance between keypoints connected by bone. Bone’s rotation is defined by its axes that are evaluated using kinematic rules and relative positions of adjacent keypoints. Method returns bone position and orientation in global world frame, final relative transformations are found traversing skeleton hierarchy and accumulating transforms of parents.

HandPoint[]

Pose keypoints

number

object

Bone transformations

hand: BoneTransform

index: BoneTransform[]

middle: BoneTransform[]

pinky: BoneTransform[]

ring: BoneTransform[]

thumb: BoneTransform[]


load(renderer): Promise<void>

Initialize plugin

Parses and caches the rig/armature of the attached scene node (one provided to plugin’s constructor). Precalculates geometrical parameters of skeleton.

Renderer<HandResult>

Renderer this plugin is attached to

Promise<void>

Promise resolving when initialization is finished

HandPlugin.load


setNode(node?): void

Set/attach a scene node

Parses and caches the rig/armature of the node. Precalculates geometrical parameters of skeleton.

TransformNode

Scene node to attach

void


setupCamera(ratio, angle): void

Set camera parameters

Could be overridden to adjust plugin’s pipeline.

number

Aspect ration of input video

number

Vertical field of view in radians

void

HandPlugin.setupCamera


setupVideo(size): void

Set video size

Could be overridden to adjust plugin’s pipeline.

Size

Resolution of input video

void

HandPlugin.setupVideo


unload(): void

Reset plugin

Clears internal state and frees all resources allocated in load().

void

HandPlugin.unload


update(result, stream): Promise<void>

Update skeleton of the scene node

Evaluates positions, rotations and scales of node bones based on estimation of 3D keypoints, then applies these transformations to bones following hierarchy of armature. One can override this method to further tune model’s rig using provided estimations of bones as a starting point. Simply call await super.update(result, stream); and use HandFitPlugin#skeletonNodes member storing refs to all bones of the skeleton to access transformations.

HandResult

Hand estimation results

HTMLCanvasElement

Captured video frame

Promise<void>

Promise resolving when update is finished

HandPlugin.update


protected updateFinger(transforms, bones): void

Update finger rig (see update)

BoneTransform[]

Finger rig ransformations

TransformNode[]

Finger bones

void