Shear6¶
#include <Imath/ImathShear.h>
The Shear6
class template represent a 3D shear transformation,
with predefined typedefs for float
and double
.
Example:
#include <Imath/ImathMatrix.h>
#include <Imath/ImathShear.h>
void
shear6_example ()
{
Imath::Shear6f s (0.330f, 0.710f, 0.010f, 0.999f, 0.531f, 0.012f);
Imath::M44f M;
M.setShear (s);
}

template<class T>
class Shear6¶ Shear6 class template.
A shear matrix is technically defined as having a single nonzero offdiagonal element; more generally, a shear transformation is defined by those offdiagonal elements, so in 3D, that means there are 6 possible elements/coefficients:
See https://www.cs.drexel.edu/~david/Classes/CS430/Lectures/L04_3DTransformations.6.pdf X'   1 YX ZX 0   X   Y'   XY 1 ZY 0   Y   Z'  =  XZ YZ 1 0  =  Z   1   0 0 0 1   1  X' = X + YX * Y + ZX * Z Y' = YX * X + Y + ZY * Z Z` = XZ * X + YZ * Y + Z
Those variable elements correspond to the 6 values in a Shear6. So, looking at those equations, “Shear YX”, for example, means that for any point transformed by that matrix, its X values will have some of their Y values added. If you’re talking about “Axis A has values from Axis B added to it”, there are 6 permutations for A and B (XY, XZ, YX, YZ, ZX, ZY).
Not that Maya has only three values, which represent the lower/upper (depending on column/row major) triangle of the matrix. Houdini is the same as Maya (see https://www.sidefx.com/docs/houdini/props/obj.html) in this respect.
There’s another way to look at it. A general affine transformation in 3D has 12 degrees of freedom  12 “available” elements in the 4x4 matrix since a single row/column must be (0,0,0,1). If you add up the degrees of freedom from Maya:
3 translation
3 rotation
3 scale
3 shear
You obviously get the full 12. So technically, the Shear6 option of having all 6 shear options is overkill; Imath/Shear6 has 15 values for a 12degreeoffreedom transformation. This means that any nonzero values in those last 3 shear coefficients can be represented in those standard 12 degrees of freedom. Here’s a python example of how to do that:
That shows how to decompose a transform matrix with one of those “extra” shear coefficients into those standard 12 degrees of freedom. But it’s not necessarily intuitive; in this case, a single nonzero shear coefficient resulted in a transform that has nonuniform scale, a single “standard” shear value, and some rotation.>>> import imath >>> M = imath.M44f() >>> s = imath.V3f() >>> h = imath.V3f() >>> r = imath.V3f() >>> t = imath.V3f() # Use Shear.YX (index 3), which is an "extra" shear value >>> M.setShear((0,0,0,1,0,0)) M44f((1, 1, 0, 0), (0, 1, 0, 0), (0, 0, 1, 0), (0, 0, 0, 1)) >>> M.extractSHRT(s, h, r, t) 1 >>> s V3f(1.41421354, 0.707106769, 1) >>> h V3f(1, 0, 0) >>> r V3f(0, 0, 0.785398185) >>> t V3f(0, 0, 0)
So, it would seem that any transform with those extra shear values set could be translated into Maya to produce the exact same transformation matrix; but doing this is probably pretty undesirable, since the result would have some surprising values on the other transformation attributes, despite being technically correct.
This usage of “degrees of freedom” is a bit handwavey here; having a total of 12 inputs into the construction of a standard transformation matrix doesn’t necessarily mean that the matrix has 12 true degrees of freedom, but the standard translation/rotation/scale/shear matrices have the right construction to ensure that.
Constructors and Assignment

inline constexpr Shear6()¶
Initialize to 0.

inline constexpr Shear6(const Vec3<T> &v)¶
Initialize to the given XY, XZ, YZ values held in (v.x, v.y, v.z)

template<class S>
inline constexpr Shear6(const Vec3<S> &v)¶ Initialize to the given XY, XZ, YZ values held in (v.x, v.y, v.z)

inline constexpr Shear6(T XY, T XZ, T YZ, T YX, T ZX, T ZY)¶
Initialize to the given (XY XZ YZ YX ZX ZY) values.

template<class S>
inline constexpr Shear6(const Shear6<S> &h)¶ Construct from a Shear6 object of another base type.

~Shear6() = default¶
Destructor.
Compatibility with Sb
Arithmetic and Comparison

inline constexpr bool equalWithAbsError(const Shear6<T> &h, T e) const¶
Compare two shears and test if they are “approximately equal”:
 Returns:
True if the coefficients of this and h are the same with an absolute error of no more than e, i.e., for all i abs (this[i]  h[i]) <= e
Numerical Limits
Public Types
Public Functions

inline constexpr T &operator[](int i)¶
Element access.
NB: This method of access uses dynamic array accesses which can prevent compiler optimizations and force temporaries to be stored to the stack and other missed vectorization opportunities. Use of direct access to xy, xz, etc when possible should be preferred.

inline constexpr const T &operator[](int i) const¶
Element access.
NB: This method of access uses dynamic array accesses which can prevent compiler optimizations and force temporaries to be stored to the stack and other missed vectorization opportunities. Use of direct access to xy, xz, etc when possible should be preferred.
Public Static Functions

static inline constexpr unsigned int dimensions()¶
Return the number of dimensions, i.e. 6.