# Stumbling Toward 'Awesomeness'

A Technical Art Blog

## BEFORE WE BEGIN

This post is about how to use vector math and trigonometric functions in Maya, it is not a linear algebra or vector math course, it should give you what you need to follow along in Maya while you learn with online materials. Kahn Academy is a great online learning resource for math, and Mathematics for Computer Graphics, and Linear Algebra and its Applications are very good books. Gilbert Strang, the Author of Linear Algebra, has his entire MIT Linear Algebra course lectures here in video form. Also, Volume 2 of Complete Maya Programming has some vector math examples in MEL and C++. ## VECTORS

Think of the white vector above as a movement. It does have three scalar values (ax, ay, az), sure, but do not think of a vector as a point or a position. When you see a vector, I believe it helps to imagine it as a movement from 0,0,0 – an origin. We don’t know where it started, we only know the movement.

A vector has been normalized, or is considered a unit vector, when it’s length is one. This is achieved by dividing each component by the length.

## VECTOR LIBRARIES

There are many Python libraries dedicated to vector math, but none ship with Python itself. I have tried numPy, then pyEuclid, and finally piMath. It can definitely be a benefit to load the same vector class across multiple apps like Maya, MotionBuilder, etc.. But, I used those in a time when MotionBuilder had no vector class, and before Maya had the API. Today, I use the vector class built into the Maya Python API (2.0), which wraps the underlying Maya C++ code: MVector

I had to call out 2.0 above, as those of you using the old API, you have to ‘cast’ your vectors to/from, meaning that classes like MVector (Maya’s vector class) don’t accept python objects like lists or tuples, this is still the case with the 2014 SWIG implementation of the default API, but not API 2.0. One solution is to override the MVector class in a way that it accepts a Python lists and tuples, essentially automatically casting it for you:

```class MVector(om.MVector): Â Â Â  def __init__(self, *args): Â Â Â Â Â Â Â  if( issubclass, args, list ) and len(args)== 3: Â Â Â Â Â Â Â Â Â Â Â  om.MVector.__init__(self, args, args, args) Â Â Â Â Â Â Â  else: Â Â Â Â Â Â Â Â Â Â Â  om.MVector.__init__(self, args)```

But that aside, just use Maya Python API 2.0:

```#import API 2.0 import maya.api.OpenMaya as om #import old API import maya.OpenMaya as om_old```

## CREATING VECTORS IN MAYA

Let’s first create two cubes, and move them

```import maya.cmds as cmds import maya.api.OpenMaya as om cube1, cube2 = cmds.polyCube(), cmds.polyCube() cmds.xform(cube2, t=(1,2,3)) cmds.xform(cube1, t=(3,5,2))```

Let’s get the translation of each, and store those as MVectors

```t1, t2 = cmds.xform(cube1, t=1, q=1), cmds.xform(cube2, t=1, q=1) print t1,t2 v1, v2 = om.MVector(t1), om.MVector(t2) print v1, v2```

This will return the translation in the form [x, y, z], and also the MVector, which will print: (x, y, z), and in the old API: <__main__.MVector; proxy of <Swig Object of type ‘MVector *’ at 0x000000002941D2D0> >. This is a SWIG wrapped C++ object, API 2.0 prints the vector.

Note: I just told you to think of vectors as a movement, and not as a position, and the first example I give stores translation in a vector. Maybe not the best, but remember this translation, is really being stored as a movement in space from an origin.

So let’s start doing stuff and things.

## LENGTH / DISTANCE / MAGNITUDE

We have two translations, both stored as vectors, let’s get the distance between them, to do this, we want to make a new vector that describes a ray from one location to the other and then find it’s length, or magnitude. To do this we subtract each component of v1 from v2:

```v = v2-v1 print v```

This results in ‘-2.0 -3.0 1.0’.

To get the length of the vector we actually get the square root of the sum of x,y,and z squared sqrt(x^2+y^2+z^2), but as we haven’t covered the math module yet, let’s just ask the MVector for the ‘length’:

`print om.MVector(v2-v1).length()`

This will return 3.74165738677, which, if you snap a measure tool on the cubes, you can verify: ## Use Case: Distance Check

As every joint in a hierarchy is in it’s parent space, a joint’s ‘magnitude’ is it’s length. Let’s create a lot of joints, then select them by joint length.

```import maya.cmds as cmds import random as r import maya.api.OpenMaya as om   root = cmds.joint() jnts = []   for i in range(0, 2000): cmds.select(cl=1) jnt = cmds.joint() trans = (r.randrange(-100,100), r.randrange(-100,100), r.randrange(-100,100)) cmds.xform(jnt, t=trans) jnts.append(jnt)   cmds.parent(jnts, root)``` So we’ve created this cloud of joints, but let’s just select those joints with a joint length of less than 50.

```sel = [] for jnt in jnts: v = om.MVector(cmds.xform(jnt, t=1, q=1)) if v.length() < 50: sel.append(jnt)   cmds.select(sel)```

## DOT PRODUCT / ANGLE BETWEEN TWO VECTORS

The dot product is a scalar value obtained by performing a specific operation on two vector components. This doesn’t make much sense, so I will tell you that the dot product is extremely useful in finding the angle between two vectors, or checking which general direction something is pointing.

```dot = v1*v2 print dot```

## USE CASE: Direction Test The dot product of two normalized vectors will always be between -1.0 and 1.0, if the dot product is greater than zero, the vectors are pointing in the same general direction, zero means they are perpendicular, less than zero means opposite directions. So let’s loop through our joints and select those that are facing the x direction:

```sel = [] for jnt in jnts: v = om.MVector(cmds.xform(jnt, t=1, q=1)).normal() dot = v*om.MVector([1,0,0]) if dot > 0.7: sel.append(jnt) cmds.select(sel)```

## USE CASE: Test World Colinearity

This one comes from last week in the office, one of my guys wanted to know how to check which way in the world something was facing. I believe it was to derive some information from arbitrary skeletons. This builds on the above by getting each vector of a node in world space.

```def getLocalVecToWorldSpace(node, vec=om.MVector.kXaxisVector): matrix = om.MGlobal.getSelectionListByName(node).getDagPath(0).inclusiveMatrix() vec = (vec * matrix).normal() return vec     def axisVectorColinearity(node, vec): vec = om.MVector(vec)   x = getLocalVecToWorldSpace(node, vec=om.MVector.kXaxisVector) y = getLocalVecToWorldSpace(node, vec=om.MVector.kYaxisVector) z = getLocalVecToWorldSpace(node, vec=om.MVector.kZaxisVector)   #return the dot products return {'x': vec*x, 'y':vec*y, 'z':vec*z}   jnt = cmds.joint() print axisVectorColinearity(jnt, [0,0,1])```

You can rotate the joint around and you will see which axis is most closely pointing to the world space vector you have given as an input.

## USE CASE: Angle Between Vectors When working with unit vectors, we can get the arc cosine of a dot product to derive the angle between the two vectors, but this requires trigonometric functions, which are not available in our vector class, for this we must import the math module. Scratching the code above, let’s find the angle between two joints:

```import maya.cmds as cmds import maya.api.OpenMaya as om import math   jnt1 = cmds.joint() cmds.select(cl=1) jnt2 = cmds.joint() cmds.xform(jnt2, t=(0,0,10)) cmds.xform(jnt1, t=(10,0,0)) cmds.select(cl=1) root = cmds.joint() cmds.parent([jnt1, jnt2], root)   v1 = om.MVector(cmds.xform(jnt1, t=1, q=1)).normal() v2 = om.MVector(cmds.xform(jnt2, t=1, q=1)).normal()   dot = v1*v2 print dot print math.acos(dot) print math.acos(dot) * 180 / math.pi```

So at the end here, the arc Cosine of the dot product returns the angle in radians (1.57079632679), which we convert to degrees by multiplying it by 180 and dividing by pi (90.0). To check your work, there is no angle tool in Maya, but you can create a circle shape and set the sweep degrees to your result.

Now that you know how to convert radians to an angle, if you store the result of the above in an MAngle class, you can ask for it however you like:

`print om.MAngle(math.acos(dot)).asDegrees()`

Now that you know how to do this, there is an even easier, using the angle function of the MVector class, you can ask it the angle given a second vector:

`print v1.angle(v2)`

There are also useful attributes v1.rotateBy(r,r,r) for an offset and v1.rotateTo(v2). I say (r,r,r) in my example, but the rotateBy attr takes angles or radians.

## USE CASE: Orient-Driver Moving along, let’s apply these concepts to something more interesting. Let’s drive a blendshape based on orientation of a joint. Since the dot product is a scalar value, we can pipe this right into a blendshape, when the dot product is 1.0, we know that the orientations match, when it’s 0, we know they are perpendicular. We will use a locator constrained to the child to help in deriving a vector. The fourByFourMatrix stores the original position of the locator. I tried using the holdMatrix node, which should store a cached version of the original locator matrix, but it kept updating. (?) We use the vectorProduct node in ‘dot product’ mode to get the dot product of the original vector and the current vector of the joint. We then pipe this value into the weight of the blendshape node.

Now, this simple example doesn’t take twist into account, and we aren’t setting a falloff or cone, the falloff will be 1.0 when the vectors align and the blendshape is on 100% and 0.0, when they’re perpendicular and the blendshape will be on 0%. I also don’t clamp the dot product, so the blendshape input can go to -1.

## CROSS PRODUCT / PERPENDICULAR VECTOR TO TWO VECTORS

The cross product results in a vector that is perpendicular to two vectors. Generally you would do (v1.y*v2.z-v1.z*v2.y, v1.z*v2.x-v1.x*v2.z, v1.x*v2.y-v1.y*v2.x), ut luckily, the vector class manages this for us by using the ‘^’ symbol:

```cross = v1^v2 print cross```

## USE CASE: Building a coordinate frame If we get the cross product of v1^v2 above, and use this vector to now cross (v1 x v2)x v1, we will now have a third perpendicular vector to build a coordinate system or ‘orthonormal basis’. A useful example would be aligning a node to a nurbs curve using the pointOnCurveInfo node. In the example above, we are using two cross products to build a matrix from the tangent of the pointOnCurveInfo and it’s position, then decomposing this matrix to set the orientation and position of a locator.

Many people put content like this behind a paywall.

posted by Chris at 11:49 PM

1. Nice tutorial. Good to see practical examples for all this vector math.

Comment by Toke Jepsen — 2014/05/12 @ 12:12 PM

2. Cool man, glad to see you post this stuff! Perhaps a good thing to mention is that cross product, unlike dot product, is non-commutative (dependent on the order of the variables). Meaning (v1 X v2) will yield an opposite vector to (v2 X v1), while dot(v1, v2) is the same as dot(v2, v1).

Comment by Dimitry Kachkovski — 2014/05/12 @ 6:24 PM

3. Thanks for this, really hand info and well put together.

Comment by Matt Murray — 2014/05/12 @ 6:49 PM

4. I don’t often comment on blogs, but this blog was super awesome! Really cleared up a lot of information for me! Thanks a ton for writing this! 🙂

Comment by Evan — 2014/06/09 @ 4:29 AM

5. You should upload the example scenes. In the ‘coordinate frame’ example you’re doing something like:
v1 = normalizedTangent^normalizedNormal
v2 = normalizedTangent^v2
Right?

I can’t seem to get such a ‘stable’ coordinate frame as in your animated gif.

Comment by Roy Nieterau — 2014/07/25 @ 2:41 PM

6. […] Stumbling Toward ‘Awesomeness’Maya: Vector Math by Example A Technical Art Blog Stumblin…. […]

7. Thanks for all this awesome information!
Been trying to reconstruct your building a coordinate frame example, but am a bit stumped as far as how to construct the 3 by 3 rotation matrix from the cross products. What vectors are v1 and v2 supposed to be using? Been reading up on google but am still a bit confused.

i can set in30, in31, and in32 to the x, y, and z position directly from the point on curve node so position is working fine.

Comment by Jamie — 2015/11/07 @ 3:17 AM

8. […] Maya: Vector Math by Example […]

Pingback by various links – Swissarmy Chainsaw Blog — 2017/11/10 @ 8:30 PM

9. […] of the most visited/indexed posts on this site was the brief Maya vector math post, now that we are releasing Python in UE4, I thought I would port those examples to UE4 […]

Pingback by Stumbling Toward 'Awesomeness'Vector Math Examples in UE4 Python - Stumbling Toward 'Awesomeness' — 2018/04/06 @ 1:24 AM

10. […] Maya: Vector Math by Example […]

Pingback by Math resources for 3d artists and animators #rigTip - Rigging Dojo — 2018/10/11 @ 11:55 AM