Chronicles of CedricK: escape from Pymel Bay

As anyone can guess the last 3 years were quite challenging: i was lucky enough to travel and work in Canada, Spain and Scotland.

I didn’t manage to update this blog in the meantime, but todays post will but related to maya development .

Last week Chris Evans wrote a post on skin-weights saving/loading in Maya, I will try to talk here about the part I find relevant and lastly elements we can improve.

Downloadable files and tool:

After a review of this task and additional information you will be able see some benchmark using different methods and tool.

The one i wrote for this occasion can be grab on my git hub account:

•  https://github.com/cedricB/skinIO

State of the art and current configuration:

Saving and loading weights is a common task any character TD will face at some point.

Usually in the rigging pipeline :

• This update can be motivated when a character model has changed.
• A rig module has changed or animation department request a special feature.

Those updates will mean our rig need to be rebuilt.

Back in the day changing skeleton layout requires people to detach their skin deformer but is no longer needed.

Another observation is that we usually are interested to updated a whole character skincluster or build it from scratch:

• loading weight on selected points is quite rare ( but easy to do ).

Practical interaction and scripting access:

On a scripting point of view this task can be done with the commands skinPercent  and skinCluster.

#lets try this code in the python script Editor
vertexToWrite = ['bodySuit.vtx[0]',
                 'bodySuit.vtx[1]',
                 'bodySuit.vtx[2]']

#when you want to write some point weights
maya.cmds.skinPercent(vertexToWrite,
                      'bodySuitSkinCluster1',
                      transformValue = ('spine1',0.5),
                                       ('spine2', 0.5)])
#We can see you can specify as argument the component you wish to act upon

This example can illustrate some of maya strong points : its nodal nature,  openness and scripting capacity  .

A very interesting design choice  was made by the maya architects:

• letting user having free access to attributes .

This freedom let you read/write data at will and connect compatible element together and this process can be done without having  to select their parent node

In contrast  in 3dsmax the skinOps command is only accessible from the command panel after  a skin modifier have been selected, unfrtunately :

• Some exposed function are broken or doesn’t support undo…

Skincluster node study:

To continue the 3dsmax analogy an operator which act on set of points is called a deformer.

• its a specialized node which only update point attributes  (so normals /position are quite common, but usually not the topology nor the uvs)

In our case a skincluster purpose is to attach a set of points to a joint and then define a smooth falloff between regions.

( above the equation in academic papers: not very useful and readable isn’t it?)

In common terms each influence will move all points rigidly ( as if the whole shape was parented to it ) and then bone vertex weights will be used to define how we mix things together.

Without any surprise the main input attribute used to define this behavior is the matrix attribute.

Each influences worldMatrix will feed this list and tell the deformer  when to update our shape point positions.

In order to parent the shape to a joint we need to convert points into this joint space:

• at bind Time Maya will store your joint worldInverseMatrix into the correct bindPrematrix attribute.

Technically weight data are stored into a compound attribute:

• each vertex will have a sparse array of float/double related to the joints influencing them
• One other fun fact is that you can connect this attribute ( maya being a nodal application remember?) to have animatable weights ( it will slow down your rig in a tremendous manner on complex character though).

This choice was mostly driven for it flexibity:

• when you paint weights or colors on a set of points having a sparse array attribute save space and memory.

Its interesting to see that this attribute is inherited from weightGeometryFilter parent class and as such is shared between all kind of deformer in maya ( very useful example of class design and inheritance).

Saving weights from the grounds up:

Now that we have a rough idea on how maya skincluster is implemented we can start looking on how this task was done through the year:

1 – Skinpercent vertex iteration:

Back in mel days we where using a combination of  fopen / fclose / fflush to write line by lines the influences index and weights list of each vertex component.

The most easy way to do that was to use a simple line separator like space.

Nowadays we can do it easily with python:

#skinData mix joint index / weights: 65 0.2 12 0.56 5 0.24
with open ('targetskinFile.txt', 'w') as targetskinFile:
    targetskinFile.write(skinData)

Python context is a really powerful tool and concept: here it will automatically close your file once it goes out of scope.

Lets see now how to actually extract some usefull data.

pointCount = maya.cmds.polyEvaluate(meshTransform, v=True)
skinCommand = 'findRelatedSkinCluster {}'.format(meshTransform)
skinDeformer = maya.mel.eval(skinCommand)

jointArray = maya.cmds.skinCluster(skinDeformer,
                                   q=True,
                                   inf=True)

for pointIndex in xrange(pointCount):
    component = '{meshTransform}.vtx[{vertexIndex}]'

    component = component.format(meshTransform=meshTransform,
                                 vertexIndex=pointIndex)

    weightData = maya.cmds.skinPercent(component,
                                       skinDeformer,
                                       q=True,
                                       value=True,
                                       ignoreBelow=0.000001)

    influenceData = maya.cmds.skinPercent(component,
                                          skinDeformer,
                                          q=True,
                                          transform=True,
                                          ignoreBelow=0.000001)

    influenceIndices = [jointArray.index(joint) for joint in jointArray]

    skinData = zip(influenceIndices, weightData)

Above you can see how to gather the weights for the provided component(most of the time vertex mesh ):

• The first lines gather the skinCluster node from the mesh history
• determines how many points are deformed ( a more robust method involves getting the skincluster set but  90 percent of time user use all shape points.
• And lastly gather the influence list

The main part of the code is then put under a loop and act on each point:

• the first skinpercent command gather weights which are above the provided threshold (ignoreBellow=0.000001)
• the second call will return an array of joint names hence the list comprehension at the end of the loop uesd to collect  their index )

( In the next update of  skinIO module on git hub you will be able to look at the pointWeight class example: it will mostly be used to benchmark and compare methods)

2 – Low level attribute parsing:

e

3 – MFnSkinCluster influence iteration:

At some point, the natural evolution of a skinweights IO tool will involve acting on components:

• It can be useful to swap sides or mirror elements.
• Sort elements and prepare data in for weight transfer (  here we can only do a one to one assigment ).

At this point most people start to look at a higher degree of abstraction to actually save/read data to/from disk.

The most popular choice in game industry  is to use Xml ( because of 3dsmax and through dotnet).

it was also choosed by maya developper to save deformer weights ( skincluster is still done through UV and texture maps… ).

Years ago when i was testing the different options to save weight faster I start by saving  them as well into an xml file.I was having correct result with python cElementTree, but on my data set Json proved to be actually faster.

One thing that stroke me is that people are still trying to export skin weights in xml on a per Vertex basis.

At some point i tried to reverse my way of thinking  and to save the data from a joint point of view:

• each influence will carry a list  of vertex index and matching list  of weights.

Lets take a look at this task by using the API  (as skinPercent -q -transform “jointToRead” average values instead of giving the list of weigts of the provided component…).

import maya.OpenMaya
import maya.OpenMayaAnim
import maya.cmds 

def get_mobject(node):
    #sample code from chad vernon
    selectionList = maya.OpenMaya.MSelectionList()
    selectionList.add(node)
    oNode = maya.OpenMaya.MObject()
    selectionList.getDependNode(0, oNode)

    return oNode

skinCommand = 'findRelatedSkinCluster {}'.format(meshTransform)
skinDeformer = maya.mel.eval(skinCommand)

#Gather some data relative to influences
jointArray = maya.cmds.skinCluster(skinDeformer,
                                   q=True,
                                   inf=True)

influenceCount = len(jointArray)

#go from command to Api world
skinClusterApiObject = get_mobject(skinDeformer)
shapeApiObj = get_mobject(shape)

shapePath   = OpenMaya.MDagPath()
maya.OpenMaya.MDagPath().getAPathTo(shapeApiObj, shapePath)

#Now we can request skin data with the API by using MFnSkinCluster
skinFunctionUtils = maya.OpenMayaAnim.MFnSkinCluster(skinClusterApiObject)

influenceObjectPaths = maya.OpenMaya.MDagPathArray()
skinFunctionUtils.influenceObjects(influenceObjectPaths) 

componentFunctionUtils = OpenMaya.MFnSingleIndexedComponent()

vertexElements = OpenMaya.MIntArray()
vertexIndexSelectionList = maya.OpenMaya.MSelectionList()
vertexWeights = maya.OpenMaya.MFloatArray()

for jointIndex in xrange(influenceCount):
    vertexComponents = OpenMaya.MObject()
    skinFunctionUtils.getPointsAffectedByInfluence(influenceObjectPaths[jointIndex],
                                                   vertexIndexSelectionList,
                                                   vertexWeights)

    if vertexIndexSelectionList.length() < 1:
        continue

    vertexIndexSelectionList.getDagPath(0, shapePath, vertexComponents)
    componentFunctionUtils.setObject(vertexComponents)
    componentFunctionUtils.getElements(vertexElements)
    skinData = zip(vertexElements, vertexWeights)

4 – MFnSkinCluster and python Api  tricks:

As seen previously,using the python API show great improvement in speed but in the end the correct answer in my case was to dump the whole shape at once:

• instead of filtering point weights below a certain threshold the APImethod will expose all values( even zero one ) for all influences .

Above sven rig strip down to only its influence object and geometries ( from autodesk open source project :  https://github.com/cedricB/skinIO/blob/master/sven.skin001.zip)

One interesting side effect is that for a mesh with 12000 vertices ( 36000 tris ) and 170 joint you will have a 2 million float list ( and no need for influence index ). As such its best to use other method if one as to process very dense mesh.

Lets see how we can do it with actual code:

e

In python it makes more sense to save this kind of data set as a whole in a binary format:

weightLength=’d’*exposedSkinData.length()
binWeights=struct.pack(weightLength,*exposedSkinData)

with open(binFile ,’wb’) as weightData:
weightData.write(binWeights)

The final product can  package every asset files into a zip archive.

(above : it made more sense to me to bundle several skincluster present into a file as a skin asset instead of having one file per element)

(above a sample of json dictionnary: each skincluster will have the same structure and point to a binary file ( either alembic or bin file))

6 – Maya ascii/binary injection:

Another alternative, opened to mel scripter and maya native user, is to take advantage of maya nature and leverage is strong points.

It is kind of sad to see nowadays softimage user bashing mel, and trying to promote pymel as the only correct way to interact with maya.(sorry but Ice and visual programming is not cool nor new to any nodal application user ).

Unfortunately pymel design which enforce object programming:

• cuts maya user from its architecture,
• uses and expose api element to beginners( messing with MObject will have terrible consequence in your UI or scripts… ( look at motionbuilder instability if you want to see one concrete example of this potential disaster)
• slower than both mel and and maya command
• carry subtle bugs
• pollutes maya namespace and scripted plugin at import times.

end of the rant…

Benchmarking and final toughts:

So the funny trick to save and load weight is to actually let maya do all the work:

• exporting a selected skincluster node in either binary or ascii format (you need to unsure no connection ,history other other accessory elements are included  at save time ).

Lets call it maya ascii/binary injection.( there is a really intersting section in the API documention on mayaAscii filter with similar concepts).

(The following test can be carried out on your side if you dowmload and use script from :

https://github.com/cedricB/skinIO

On my laptop using Chris script ( after correcting the missing import statements )

sven Export weight methods will produce this result  in the script editor:

Exported skinWeights for 22 meshes in 1.80200004578 seconds.

The binary extraction methods from the script I will share on github:
———————————————————————-
Processings took 0.82452176412 seconds

The ascii extraction methods
———————————————————————-
Processings took 2.28121973499 seconds

(slower but still reasonable with retrospective to the amount of work involved… )

The last methods will take advantage of alembic cache node:
Saving 22 elements took 0.473954696144 seconds
Export to D:/SuitSkinCluster1.abc was successful
Geometry SuitShape
Number of vertex 18148
Number of influences 216
Number of weights Samples 3919968
———————————————————————-
Processings took 0.313700978128 seconds

(SKIPPING 21 other elements)
———————————————————————-
Processings took 0.516421672774 seconds

Thats it for today, I hope you had a good read.

Advertisements

A journey in the realm of corrective shapes III: lessons learned so far…

After several weeks of tough struggle and failure I was able to reach an acceptable point in my personal cartoon rig project.

This post will try to explain the process and reasoning that lead to this result.( In the coming weeks i will try to finish some previous article on this blog, and share new tools on creative crash or github.)

(above: unbreakable deformation system for cartoon character)

1) Building rig from simple tools : layering elements by function

( above : some broad concepts on character articulation, and  solutions I tried to find in order consolidate the puppet building workflow )

a) Aim quaternion node :

e

b) Custom articulation Curve and pathSegment node : driving large array of bones efficiently.
e

c) Brute force pose space deformation : a look at corrective shapes database handling

( first look at the leg deformation system: notice the quaternion controller which defines a default twist value)

e

2) Writing toon oriented deformer: a math-less method.
e

Protocol to build a reusable deformation template II: a brute force approach

Over the last months I was busy writing and playing with specialized rigging and deformation nodes for maya .

I asked my former mentor at rigging dojo, Brad Clark, some advices on my newly released programming reel . He gave me a really helpful insight on my spline deformer and ask how will it behaves on a full blow creature or character.

I quickly realized that much of the previous tools were proof of concept, that needs further development to be useful in a real world scenario. This was good opportunity to apply my research on practical examples.

( above, the list of character that will be used to test out plugins and tools: there is a progression in the difficulty to articulate them, going from pure cartoon , to caricature and realistic model )

1) Hall of fame ( full credit list disclosure…) :

Most of the time when I recycle a model I try to tweak it by working on its topology , proportion, or form .

The following images will describe what was done and their original author

Mr Noogles from Brad Clark, works done:

• hands and feet consolidation
• face retopology and neutral expression

Package Man , Javier Solsona :

• ears and nose extensive modification
• face retopology and consolidation
• hand consolidation
• body retopology

Zazar, concept and story from my friend jean-luc Patriat ( Hanuman ) work in progress:

• initial model : cedric bazillou
• tail and cloth removal
• anatomy detail from various free model
• tweaking and consolidation

Female model found on pixologic forum ( contact me if you know the author, to give him/her well deserved credit ( you rules man…) )

2) Integrating topology varying limbs in character puppet:

To test out rubber hose arm and leg it was obvious to search a simple cartoon character where extreme stretchable limb was part of the design.

On this character the main shapes are easily identified :

• The torso mimic the form of an inverted water drop
• the face mask is placed on the upper portion of the body and seems to slide along the torso surface.

For this project the hands and feet were rebuilt ,  an equal number of faces  were also distributed along the character limbs.

You can also see from the original mesh on the left that I did an extensive work on the face to have a  neutral starting point( the asymmetrical feature of the face works great and gives this character an insane expression) .

To reach my goal I though of splitting its body into meaningful regions.The arm , spine and leg were to be stretchable but i wanted to avoid the most common mistake done by average rigger: skewing large portion of the shoulder or hips when a limb length increase or shrink.

The light salmon color faces will be deformed by my custom spline deformer,when stretched this region will automatically increase its edge subdivision along the curve length.

The other faces will use regular basic skinning and extensive pose space deformation.

3) Taming  ankles: teaching toon how to tilt

One common test I perform to check how the ankle region behaves , is to tilt a character a la “smooth criminal”. Above we can see Michael Jackson leaning at an angle of 40 degrees, which in itself is already spectacular, but for a cartoon is not enough.

(above: the feet are firmly planted  on the ground demonstrating an unbreakable deformation rig)

To reach this goal I work a couple of days in order to update 2 tools featured in a previous article :

• the sextant and hemisphere node.

It was important to script the the corrective shape setup  as well to have a general tool to manage and update the required corrective shapes.

( above: you can see the ankle describing a circle and the combination of up and left side will push the foot on the left side)

After my previous experiment ,failure and disappointment in pose space deformation , I wanted to try other method  to do the correctives shapes:

• encoding a predefined orientation into the articulation .

The result was more pleasing and easy to achieve :

• the setup start with 4 shapes up/ down then right/left
• at this stage the space is divided into 2 or 3 ( depending on the granularity that is needed for a creature ), each subspace being dependent to the previous one
• the last 16 shapes(in pink in the image ) will be used to enable a smooth blending between this set of target key pose.

Less shape were also needed  by using comet pose deformer on top of the skin cluster: as an additive offset the vertex are inheriting the arc motion of the joints influencing them ,producing a smoother interpolation.

4) geodesic wrist : an animator-proof articulation…

Above: Range of motion for the wrist, notice the smooth interpolation of the corrective shapes that distributes the edges of the mesh evenly.

The correctives shape embed a predefined torsion value into several key poses in order to have beautiful deformation when the wrist is locked and before a second twist layer is added to the forearm.

After playing a lot with spherical coordinates I wanted to try another workflow to interpolate and create corrective shapes.Instead of stacking the influence of all shapes , only 3 morphs would be active at any time.

To compute vertex weight the most easy way was to extract from a ray/mesh intersection the barycenter value . Other type of interpolation( UV based, face sweeping etc ) is also possible with this method and can be a viable alternative to simple vector angle based poseReader.

(Above: the 16 corrective shapes used for this wrist : the triangulated mesh in the center of the image output vertex weights that are linked to their related key pose )

b) Elbow deformation with custom trigger node:

Range of motion for this character elbow : beyond 130 degrees the forearm starts to collide with the biceps and push the flesh on the side and on the back

A better view for the arm bulging: on this example simple correctives shapes define the overall deformation , but a self collision plane can be used to trigger animated weights for the last shape.

e