Пример #1
0
    def updateTRS(self, expectedTRS, op, v, space=om.MSpace.kWorld):
        '''Update the expected vector based on given operation, vector and space
        The expectedTRS vector has 9 entries:
        * 0-2 The world position
        * 3-5 The world rotation (in degrees)
        * 6-8 The world scale
        The possible operations are move, rotate, and scale.
        The possible spaces are kObject and kWorld (default)
        '''
        if (expectedTRS is None):
            expectedTRS = [None] * 9
        # trs starts as the identity matrix
        #
        trs = om.MTransformationMatrix()

        # Add translation, rotation, and scale, in world space, to recreate
        # the last transformation matrix.
        #
        if (expectedTRS[0] is not None):
            trs.setTranslation(
                om.MVector(expectedTRS[0], expectedTRS[1], expectedTRS[2]),
                om.MSpace.kWorld)
        if (expectedTRS[3] is not None):
            trs.setRotation(
                om.MEulerRotation(radians(expectedTRS[3]),
                                  radians(expectedTRS[4]),
                                  radians(expectedTRS[5])))
        if (expectedTRS[6] is not None):
            trs.setScale(
                om.MVector(expectedTRS[6], expectedTRS[7], expectedTRS[8]),
                om.MSpace.kWorld)
        # Apply the requested operation. If the space is kObject, and we had a
        # scale factor, we must counteract it to get the right matrix, by
        # dividing the translation vector by it (otherwise it ends up being
        # scaled twice, and the expected value is incorrect).
        #
        if op == self.move:
            if (space == om.MSpace.kObject and expectedTRS[6] is not None):
                trs.translateBy(
                    om.MVector(v[0] / expectedTRS[6], v[1] / expectedTRS[7],
                               v[2] / expectedTRS[8]), space)
            else:
                trs.translateBy(om.MVector(v[0], v[1], v[2]), space)
        elif op == self.rotate:
            trs.rotateBy(
                om.MEulerRotation(radians(v[0]), radians(v[1]), radians(v[2])),
                space)
        elif op == self.scale:
            trs.scaleBy(om.MVector(v[0], v[1], v[2]), space)
        # Recover the world space translate, rotate, and scale, and updated
        # the expected vector
        #
        expectedTRS[0:3] = trs.translation(om.MSpace.kWorld)
        r = trs.rotation().asVector()
        expectedTRS[3] = degrees(r[0])
        expectedTRS[4] = degrees(r[1])
        expectedTRS[5] = degrees(r[2])
        expectedTRS[6:9] = trs.scale(om.MSpace.kWorld)
        return expectedTRS
Пример #2
0
 def test_setRotation(self):
     con = control.Control(name="testControl")
     con.create(shape="arrow")
     con.setRotation(om2.MEulerRotation(10, 10, 10))
     trans = om2.MFnTransform(con.dagPath.node())
     rot = trans.rotation()
     self.assertEquals(rot, om2.MEulerRotation(10, 10, 10))
     con.setRotation(om2.MEulerRotation(-10, -10, -10), cvs=True)
     # probably should test the cv locations
     self.assertEquals(trans.rotation(), om2.MEulerRotation(10, 10, 10))
Пример #3
0
def getObjectWorldOrientation(node):
    if(node is None):
        return None
        
    jointRot = getJointWorldOrientation(node) if isJoint(node) else om.MEulerRotation()
    
    rot = cmds.xform(node, query=True, translation=False, rotation=True, absolute=True)
    rotOrder = mayaMathUtil.nodeRotOrderToEulerRotOrder(cmds.xform(node, query=True, rotateOrder=True, absolute=True))
    
    objRot = om.MEulerRotation(math.radians(rot[0]), math.radians(rot[1]), math.radians(rot[2]), rotOrder)
    
    return objRot * jointRot
Пример #4
0
    def compute(self, plug, dataBlock):
        if plug is not self.expmap and plug not in self.expmapElement:
            return

        r = [0, 0, 0]
        for i in xrange(0, 3):
            rHandle = dataBlock.inputValue(mlEulerToExpmap.eulerAngles[i])
            r[i] = rHandle.asDouble()
        roHandle = dataBlock.inputValue(mlEulerToExpmap.rotateOrder)
        rotateOrder = roHandle.asInt()
        eulerRotation = OpenMaya.MEulerRotation(r[0], r[1], r[2], rotateOrder)
        q = eulerRotation.asQuaternion()
        if q.w < 0:
            q = -q
        if math.fabs(q.w) > 1.0 - 1.0e-6:
            a = 0.0
            isina = 0.0
        else:
            a = math.acos(q.w)
            isina = a / math.sin(a)
        ln = (q.x * isina, q.y * isina, q.z * isina)
        for i in xrange(0, 3):
            outputHandle = dataBlock.outputValue(
                mlEulerToExpmap.expmapElement[i])
            outputHandle.setDouble(ln[i])
        dataBlock.setClean(plug)
Пример #5
0
    def get_local_matrix(self, node, invertJointOrient=False):

        local_mx = cmds.xform(node, m=1, q=1)
        #ignore code below for now - that code will take joint orient into account
        return local_mx

        if invertJointOrient:
            # if it's a joint, lets remove the joint orient from the local matrix
            if cmds.nodeType(node) == "joint":
                selList = api.MGlobal.getSelectionListByName(node)
                dagPath = selList.getDagPath(0)

                parentMatrix = dagPath.exclusiveMatrix()
                worldMatrix = dagPath.inclusiveMatrix()

                jointOrient = cmds.getAttr(node + ".jointOrient")[0]
                x = math.radians(jointOrient[0])
                y = math.radians(jointOrient[1])
                z = math.radians(jointOrient[2])
                joEuler = api.MEulerRotation(x, y, z)
                joMatrix = joEuler.asMatrix()

                localMatrix = worldMatrix * parentMatrix.inverse()
                orientLocalMatrix = localMatrix * joMatrix.inverse()

                # combine the orient local matrix and the translation which shouldn't be changed based on the orientation
                for i in range(12):
                    localMatrix[i] = orientLocalMatrix[i]

                # set the local matrix to this
                local_mx = localMatrix

        return local_mx
Пример #6
0
def _mirror_rotation(parent_matrix, m_parent_matrix, rot):
    """this mirrors the rotation"""

    driver_mat_fn = api.MTransformationMatrix(api.MMatrix.kIdentity)

    # set the values to radians
    rot[0] = math.radians(rot[0])
    rot[1] = math.radians(rot[1])
    rot[2] = math.radians(rot[2])

    euler = api.MEulerRotation(rot[0], rot[1], rot[2])

    driver_mat_fn.setRotation(euler)
    driver_matrix = driver_mat_fn.asMatrix()

    world_matrix = driver_matrix * parent_matrix
    rot_matrix = parent_matrix.inverse() * world_matrix
    rot_matrix_fn = api.MTransformationMatrix(rot_matrix)
    rot = rot_matrix_fn.rotation(asQuaternion=True)
    rot.x = rot.x * -1.0
    rot.w = rot.w * -1.0
    rot_matrix = rot.asMatrix()
    final_rot_matrix = m_parent_matrix * rot_matrix * m_parent_matrix.inverse()

    rot_matrix_fn = api.MTransformationMatrix(final_rot_matrix)
    rot = rot_matrix_fn.rotation(asQuaternion=False)
    m_rot = api.MVector()
    m_rot[0] = math.degrees(rot[0])
    m_rot[1] = math.degrees(rot[1])
    m_rot[2] = math.degrees(rot[2])

    return m_rot
Пример #7
0
 def usdSceneItemRotation(item):
     prim = usdUtils.getPrimFromSceneItem(item)
     if not prim.HasAttribute('xformOp:rotateXYZ'):
         return proxyShapeXformFn.rotation(om.MSpace.kTransform)
     else:
         x,y,z = prim.GetAttribute('xformOp:rotateXYZ').Get()
         return  proxyShapeXformFn.rotation(om.MSpace.kTransform) + om.MEulerRotation(radians(x), radians(y), radians(z))
Пример #8
0
    def compute(self, plug, dataBlock):
        if plug is not self.rotate and plug not in self.eulerAngles:
            return

        rv = [0.0, 0.0, 0.0]
        for i in xrange(0, 3):
            inputHandle = dataBlock.inputValue(
                mlExpmapToEuler.expmapElement[i])
            rv[i] = inputHandle.asDouble()
        orderHandle = dataBlock.inputValue(mlExpmapToEuler.rotateOrder)
        exHandle = dataBlock.outputValue(mlExpmapToEuler.eulerAngles[0])
        eyHandle = dataBlock.outputValue(mlExpmapToEuler.eulerAngles[1])
        ezHandle = dataBlock.outputValue(mlExpmapToEuler.eulerAngles[2])
        mag = math.sqrt(rv[0] * rv[0] + rv[1] * rv[1] + rv[2] * rv[2])
        if math.fabs(mag) < 1.0e-6:
            sina = 0
        else:
            sina = math.sin(mag) / mag
        quat = OpenMaya.MQuaternion(rv[0] * sina, rv[1] * sina, rv[2] * sina,
                                    math.cos(mag))
        order = orderHandle.asInt()
        euler = OpenMaya.MEulerRotation(0, 0, 0, order)
        euler *= quat
        exHandle.setDouble(euler.x)
        eyHandle.setDouble(euler.y)
        ezHandle.setDouble(euler.z)
        dataBlock.setClean(plug)
Пример #9
0
def flip_euler(euler, rotation_order):
    """Resolve flipping rotations in cases where flipping occurs on multiple 
    different channels; middle rotations are offloaded to outer rotations.
    
    Args:
        euler(OpenMaya.MEulerRotation): rrotation to adjust for flipping.
        rotation_order(str): order in which channels are rotated eg. xyz.
    Returns:
        euler(OpenMaya.MEulerRotation): rotation adjusted for flipping channels.
    """

    result = OpenMaya.MEulerRotation()
    inner_axis = rotation_order[0]
    middle_axis = rotation_order[1]
    outer_axis = rotation_order[2]

    inner_value = getattr(euler, inner_axis) + math.pi
    setattr(result, inner_axis, inner_value)

    outer_value = getattr(euler, outer_axis) + math.pi
    setattr(result, outer_axis, outer_value)

    middle_value = getattr(euler, middle_axis) * -1 + math.pi
    setattr(result, middle_axis, middle_value)

    return result
Пример #10
0
    def _getLocalTransform(self):
        node = self.thisMObject()

        transformPlug = om.MPlug(node, self.transformAttr)
        transform = om.MFnMatrixData(transformPlug.asMObject()).matrix()

        mat = om.MTransformationMatrix(transform)

        # Apply local translation.
        localTranslatePlug = om.MPlug(node, self.localTranslateAttr)
        localTranslation = om.MVector(
            *[localTranslatePlug.child(idx).asFloat() for idx in range(3)])
        mat.translateBy(localTranslation, om.MSpace.kObject)

        # Apply local rotation.
        localRotatePlug = om.MPlug(node, self.localRotateAttr)
        localRotatePlugs = [localRotatePlug.child(idx) for idx in range(3)]
        localRotate = om.MVector(
            *
            [localRotatePlugs[idx].asMAngle().asRadians() for idx in range(3)])
        mat.rotateBy(om.MEulerRotation(localRotate), om.MSpace.kObject)

        # Apply local scale.
        scalePlug = om.MPlug(node, self.localScaleAttr)
        scale = om.MFnNumericData(scalePlug.asMObject()).getData()
        mat.scaleBy(scale, om.MSpace.kObject)

        return mat.asMatrix()
Пример #11
0
def aimNode(node,target, myAimAxis=[1,0,0], myUpAxis=[0,1,0], myUpDir=[0,0,1]):
    """rotate a transform to aim a target point
    Args:
        node (str): transform node name
        target (list): world space point expresed as [float, float, float]
        myAimAxis (list, optional): the axis that point to the target. Defaults to [1,0,0].
        myUpAxis (list, optional): the axis up to stabilize the rotation. Defaults to [0,1,0].
        myUpDir (list, optional): [description]. Defaults to [0,0,1].
    """    
    selList = om.MSelectionList()
    selList.add(node)
    mdpThis = selList.getDagPath(0)
    mpTarget=om.MPoint(target)

    mmMatrix = mdpThis.inclusiveMatrix();
    mmMatrixInverse = mmMatrix.inverse();
    mpTargetInThisSpace=om.MPoint(mpTarget * mmMatrixInverse);
    mqToTarget=om.MQuaternion (om.MVector(myAimAxis).rotateTo(om.MVector(mpTargetInThisSpace)));
    # Apply that rotation to this node:
    mftThis=om.MFnTransform (mdpThis.transform());
    mftThis.rotateBy(mqToTarget, om.MSpace.kPreTransform);
    
    mmMatrix = mdpThis.inclusiveMatrix();
    mmMatrixInverse = mmMatrix.inverse();
    mvUp=om.MVector(myUpDir)
    mpWorldUpInThisSpace=om.MPoint (mvUp * mmMatrixInverse);
    # Get the quaternion that describes the rotation to make the local up vector point to the world up vector:
    mqToWorldUp=om.MQuaternion (om.MVector(om.MVector(myUpAxis)).rotateTo(om.MVector(mpWorldUpInThisSpace)));
    merToWorldUp=om.MEulerRotation (mqToWorldUp.asEulerRotation());
    merToWorldUp.y = 0.0;
    merToWorldUp.z = 0.0;
    # Apply that rotation to this node:
    mftThis.rotateBy(merToWorldUp, om.MSpace.kPreTransform);
Пример #12
0
    def _assume_t_pose(self, segment):
        transformFn = self._segments[int(segment["@ID"])]["transformFn"]

        if self._up_axis == "y":
            translation = om.MVector(
                -float(segment["Position"]["@X"]) * self._unit_conversion,
                float(segment["Position"]["@Z"]) * self._unit_conversion,
                float(segment["Position"]["@Y"]) * self._unit_conversion,
            )
        else:
            translation = om.MVector(
                float(segment["Position"]["@X"]) * self._unit_conversion,
                float(segment["Position"]["@Y"]) * self._unit_conversion,
                float(segment["Position"]["@Z"]) * self._unit_conversion,
            )

        transformFn.setTranslation(translation, om.MSpace.kTransform)
        transformFn.setRotation(
            om.MEulerRotation(
                float(segment["Rotation"]["@X"]),
                float(segment["Rotation"]["@Y"]),
                float(segment["Rotation"]["@Z"]),
                om.MEulerRotation.kXYZ,
            ),
            om.MSpace.kTransform,
        )
Пример #13
0
    def angleCompute( self , axeDir , oTrs , baseTrs , trs ):       

        axeDirSkip = [ [ 0 , 1 , 1 ] , [ 1 , 0 , 1 ] , [ 1 , 1 , 0 ]  ] 
        # vINIT
        
        way = 1
        if( 2 < axeDir ):
            axeDir -= 3
            way     = -1
        
        vBaseInitValue         = [0,0,0]
        vBaseInitValue[axeDir] = way
        vBaseInit   = ompy.MVector( vBaseInitValue[0]    ,  vBaseInitValue[1]    , vBaseInitValue[2]     )  
        
        # INVERSE ROTATION ORIGINE  
        eulerInit   = ompy.MEulerRotation( math.radians(oTrs[3]) , math.radians(oTrs[4]) , math.radians(oTrs[5]) )
        eulerInit.invertIt()        

        # vTARGET           
        vTarget   = ompy.MVector( trs[0]     - oTrs[0] ,  trs[1]     - oTrs[1] , trs[2]     - oTrs[2]  )        
        vTarget   = vTarget.rotateBy(eulerInit)

        # ANGLE BASE TARGET 
        rotQuat = ompy.MQuaternion( vBaseInit , vTarget )
        rotEuler = rotQuat.asEulerRotation()

        # ANGLE SKIP AXE        
        angleOut = [ rotEuler.x * axeDirSkip[axeDir][0] , rotEuler.y * axeDirSkip[axeDir][1] , rotEuler.z * axeDirSkip[axeDir][2]  ]
        
        # ANGLE OUT     
        angleOut = [ math.degrees(angleOut[0]) , math.degrees(angleOut[1]) , math.degrees(angleOut[2]) ]
        
        return angleOut             
Пример #14
0
    def change(self, diff):
        if self.originalRotation is None:
            return

        if self.index == 0:
            diffRotation = om.MEulerRotation(diff, 0, 0)
        elif self.index == 1:
            diffRotation = om.MEulerRotation(0, diff, 0)
        elif self.index == 2:
            diffRotation = om.MEulerRotation(0, 0, diff)
        else:
            diffRotation = om.MEulerRotation(0, 0, 0)

        self.newRotation = self.originalRotation + diffRotation

        objectXform = om.MFnTransform(self.dagPath)
        objectXform.setRotation(self.newRotation, om.MSpace.kTransform)
Пример #15
0
def asEuler(rotation):
    """Converts tuple(float3) into a MEulerRotation

    :param rotation: a tuple of 3 elements in degrees which will be converted to redians for the eulerRotation
    :type rotation: tuple(float)
    :rtype: MEulerRotation
    """
    return om2.MEulerRotation(
        [om2.MAngle(i, om2.MAngle.kDegrees).asRadians() for i in rotation])
Пример #16
0
def getMatrices(node):
    nodeName = OpenMaya.MFnDagNode(node).getPath()

    r = cmds.getAttr('{0}.r'.format(nodeName))
    r = [math.radians(x) for x in r[0]]
    ra = cmds.getAttr('{0}.ra'.format(nodeName))
    ra = [math.radians(x) for x in ra[0]]
    jo = cmds.getAttr('{0}.jo'.format(nodeName))
    jo = [math.radians(x) for x in jo[0]]

    wm = OpenMaya.MMatrix(cmds.getAttr('{0}.wm'.format(nodeName)))
    pm = OpenMaya.MMatrix(cmds.getAttr('{0}.pm'.format(nodeName)))

    r = OpenMaya.MEulerRotation(*r).asMatrix() * pm
    ra = OpenMaya.MEulerRotation(*ra).asMatrix() * pm
    jo = OpenMaya.MEulerRotation(*jo).asMatrix() * pm

    return wm, r, ra, jo
Пример #17
0
    def set_rotation(self, x, y, z):
        """Set the absolute rotation of the curve shape in euler rotations.

        :param x: Rotate X
        :param y: Rotate Y
        :param z: Rotate Z
        """
        x, y, z = [v * 0.0174533 for v in [x, y, z]]
        self.transform_matrix.setRotation(OpenMaya.MEulerRotation(x, y, z))
Пример #18
0
    def rotate_by(self, x, y, z, local=True):
        """Rotate the curve cvs by the given euler rotation values

        :param x: Rotate X
        :param y: Rotate Y
        :param z: Rotate Z
        :param local: True for local space, False for world
        """
        x, y, z = [v * 0.0174533 for v in [x, y, z]]
        space = OpenMaya.MSpace.kObject if local else OpenMaya.MSpace.kWorld
        self.transform_matrix.rotateBy(OpenMaya.MEulerRotation(x, y, z), space)
Пример #19
0
def setMayaRotation(aMayaItem, r):
    '''Set the rotation (XYZ) on the argument Maya scene item.'''

    aMayaPath = aMayaItem.path()
    aMayaPathStr = ufe.PathString.string(aMayaPath)
    aDagPath = om.MSelectionList().add(aMayaPathStr).getDagPath(0)
    aFn = om.MFnTransform(aDagPath)
    rads = [radians(v) for v in r]
    rot = om.MEulerRotation(rads[0], rads[1], rads[2])
    aFn.setRotation(rot, om.MSpace.kTransform)
    return (aMayaPath, aMayaPathStr, aFn, aFn.transformation().asMatrix())
Пример #20
0
def euler_to_quat(eulers, transforms):
    """Convert a list of eulers to quaternions

    :param eulers: List of tuples or lists of length 3
    :param transforms: List of transforms per rotation
    :return: List of quaternions
    """
    quats = []
    for i, v in enumerate(eulers):
        rotate_order = cmds.getAttr("{}.ro".format(transforms[i]))
        r = [math.radians(x) for x in v]
        euler = OpenMaya.MEulerRotation(r[0], r[1], r[2], rotate_order)
        q = euler.asQuaternion()
        if cmds.nodeType(transforms[i]) == "joint":
            jo = cmds.getAttr("{}.jo".format(transforms[i]))[0]
            jo = [math.radians(x) for x in jo]
            jo = OpenMaya.MEulerRotation(jo[0], jo[1], jo[2])
            q *= jo.asQuaternion()
        quats.append([q.x, q.y, q.z, q.w])
    return quats
Пример #21
0
def mirrorJoint(node, parent, translate, rotate):
    nFn = om2.MFnDependencyNode(node)
    rotateOrder = nFn.findPlug("rotateOrder", False).asInt()
    transMatRotateOrder = generic.intToMTransformRotationOrder(rotateOrder)
    translation, rotMatrix = mirrorTransform(node, parent, translate, rotate)  # MVector, MMatrix
    jointOrder = om2.MEulerRotation(plugs.getPlugValue(nFn.findPlug("jointOrient", False)))
    # deal with joint orient
    jo = om2.MTransformationMatrix().setRotation(jointOrder).asMatrixInverse()
    # applyRotation and translation
    rot = mayamath.toEulerFactory(rotMatrix * jo, transMatRotateOrder)
    setRotation(node, rot)
    setTranslation(node, translation)
Пример #22
0
def toEulerZYX(rotMatrix, degrees=False):
    rotZX = rotMatrix[8]
    y = math.asin(rotZX)
    cosY = math.cos(y)

    x = math.atan2(-rotMatrix[9] * cosY, rotMatrix[10] * cosY)
    z = math.atan2(-rotMatrix[4] * cosY, rotMatrix[0] * cosY)

    angles = x, y, z

    if degrees:
        return map(math.degrees, angles)

    return om2.MEulerRotation(angles)
Пример #23
0
def toEulerZXY(rotMatrix, degrees=False):
    rotZY = rotMatrix[9]
    x = -math.asin(rotZY)
    cosX = math.cos(x)

    z = math.atan2(rotMatrix[1] * cosX, rotMatrix[5] * cosX)
    y = math.atan2(rotMatrix[8] * cosX, rotMatrix[10] * cosX)

    angles = x, y, z

    if degrees:
        return map(math.degrees, angles)

    return om2.MEulerRotation(angles)
Пример #24
0
def toEulerYZX(rotMatrix, degrees=False):
    rotYX = rotMatrix[4]
    z = -math.asin(rotYX)
    cosZ = math.cos(z)

    x = math.atan2(rotMatrix[6] * cosZ, rotMatrix[5] * cosZ)
    y = math.atan2(rotMatrix[8] * cosZ, rotMatrix[0] * cosZ)

    angles = x, y, z

    if degrees:
        return map(math.degrees, angles)

    return om2.MEulerRotation(angles)
Пример #25
0
def toEulerYXZ(rotMatrix, degrees=False):
    rotZ = rotMatrix[6]
    x = math.asin(rotZ)
    cosX = math.cos(x)

    y = math.atan2(-rotMatrix[2] * cosX, rotMatrix[10] * cosX)
    z = math.atan2(-rotMatrix[4] * cosX, rotMatrix[5] * cosX)

    angles = x, y, z

    if degrees:
        return map(math.degrees, angles)

    return om2.MEulerRotation(angles)
Пример #26
0
def toEulerXZY(rotMatrix, degrees=False):
    rotYY = rotMatrix[1]
    z = math.asin(rotYY)
    cosZ = math.cos(z)

    x = math.atan2(-rotMatrix[9] * cosZ, rotMatrix[5] * cosZ)
    y = math.atan2(-rotMatrix[2] * cosZ, rotMatrix[0] * cosZ)

    angles = x, y, z

    if degrees:
        return map(math.degrees, angles)

    return om2.MEulerRotation(angles)
Пример #27
0
 def test_create_twist_composition_at_p5_non_inverted(self):
     st.create_swing_twist(self.start_joint,
                           self.twist_joint,
                           twist_weight=0.5)
     cmds.setAttr("{}.rx".format(self.start_joint), 45)
     m = self.local_matrix()
     tm = OpenMaya.MTransformationMatrix()
     tm.rotateBy(
         OpenMaya.MEulerRotation(math.radians(22.5), 0, 0),
         OpenMaya.MSpace.kTransform,
     )
     tm.translateBy(OpenMaya.MVector(self.tx, 0, 0),
                    OpenMaya.MSpace.kTransform)
     self.assertListAlmostEqual(m, tm.asMatrix())
Пример #28
0
def apply_euler_filter_to_transformed_data(transformed_data,
                                           frames,
                                           rotation_order='xyz'):
    """Apply filter to fix channel flipping on euler rotations.

    This function changes the values of the given transformed_data dictionary.
    
    Args:
        transformed_data(dict): data off all transforms along given frames.
        frames(list): list of frames to iterate, in ascending order.
        rotation_order(str): rotation order of the object to apply filter on.
    """
    euler_data = {}
    for frame in frames:
        if (frame - 1) not in transformed_data:
            continue

        current_rotation = transformed_data[frame]['r']
        previous_rotation = transformed_data[frame - 1]['r']

        # apply basic flipping filter for 180 degree flips on one channel
        new_rotation = OpenMaya.MEulerRotation()
        new_rotation.x = account_for_flip(previous_rotation.x,
                                          current_rotation.x)
        new_rotation.y = account_for_flip(previous_rotation.y,
                                          current_rotation.y)
        new_rotation.z = account_for_flip(previous_rotation.z,
                                          current_rotation.z)

        # apply flipping filter for multi channel flipping
        result_rotation = flip_euler(new_rotation, rotation_order)
        result_rotation.x = account_for_flip(previous_rotation.x,
                                             result_rotation.x)
        result_rotation.y = account_for_flip(previous_rotation.y,
                                             result_rotation.y)
        result_rotation.z = account_for_flip(previous_rotation.z,
                                             result_rotation.z)

        # apply the filter based on which value has a smaller distance
        # from the original rotation.
        new_rotation_distance = euler_rotation_distance(
            previous_rotation, new_rotation)
        result_rotation_distance = euler_rotation_distance(
            previous_rotation, result_rotation)

        if result_rotation_distance < new_rotation_distance:
            new_rotation = result_rotation

        transformed_data[frame]['r'] = new_rotation
Пример #29
0
	def setRotation(self, vector, radians = False):
		""" Set rotation. 
			Set radians = True to set it in randians. 
			
			Parameters:
				vector (Tuple(x,y,z) or MVector)
				space (Space.CONSTANT) 
					Default Space.WORLD: 
					Space.LOCAL, Space.WORLD, SpaceTRANSFORM"""

		if radians == False:
			rotation = self.vectorDegreesToRadians(vector)

		eulerAngle = om.MEulerRotation(rotation, RotOrder.XYZ)
		self._fnTransform.setRotation(eulerAngle.asQuaternion(), Space.WORLD)
Пример #30
0
    def runMultiSelectTestRotate(self, items, expected):
        '''Engine method to run multiple selection rotate test.'''

        # Save the initial positions to the memento list.
        self.multiSelectSnapShotAndTest(items, expected)

        # Do some rotate commands, and compare with expected. 
        for x, y, z in [[10, 20, 30], [-30, -20, -10]]:
            cmds.rotate(x, y, z, relative=True, objectSpace=True, forceOrderXYZ=True) # Just as in default rotations by manipulator
            expected = multiSelectAddRotations(expected, om.MEulerRotation(radians(x), radians(y), radians(z)))
            self.multiSelectSnapShotAndTest(items, expected)

        # Test undo, redo.
        self.multiSelectRewindMemento(items)
        self.multiSelectFforwardMemento(items)