Python cmds.spaceLocator方法代码示例

# 需要导入模块: from maya import cmds [as 别名]
# 或者: from maya.cmds import spaceLocator [as 别名]
def middlePoint(self, a, b, createLocator=False, *args):
        """ Find the point location in the middle of two items.
            Return the middle point position as a vector and a locator in it if want.
        """
        if cmds.objExists(a) and cmds.objExists(b):
            # get xform datas:
            aPos = cmds.xform(a, query=True, worldSpace=True, rotatePivot=True)
            bPos = cmds.xform(b, query=True, worldSpace=True, rotatePivot=True)
            # calculating the result position:
            resultPosX = ( aPos[0] + bPos[0] )/2
            resultPosY = ( aPos[1] + bPos[1] )/2
            resultPosZ = ( aPos[2] + bPos[2] )/2
            resultPos = [resultPosX, resultPosY, resultPosZ]
            if createLocator:
                middleLoc = cmds.spaceLocator(name=a+"_"+b+"_Middle_Loc", position=resultPos)[0]
                cmds.xform(middleLoc, centerPivots=True)
                return [resultPos, middleLoc]
            return[resultPos] 

# 需要导入模块: from maya import cmds [as 别名]
# 或者: from maya.cmds import spaceLocator [as 别名]
def test_seamless_switch(self):
        target = cmds.spaceLocator()[0]
        driver1 = cmds.spaceLocator()[0]
        cmds.setAttr("{}.t".format(driver1), 10, 0, 5)
        driver2 = cmds.spaceLocator()[0]
        cmds.setAttr("{}.t".format(driver2), -5, 2, 1)
        cmds.setAttr("{}.r".format(driver2), 40, 0, 0)

        ss.create_space_switch(
            target, [(driver1, "local"), (driver2, "world")], "space"
        )

        cmds.setAttr("{}.rx".format(driver1), 30)
        m1 = cmds.getAttr("{}.worldMatrix[0]".format(target))

        ss.switch_space(target, "space", 1)

        m2 = cmds.getAttr("{}.worldMatrix[0]".format(target))
        self.assertListAlmostEqual(m1, m2) 

# 需要导入模块: from maya import cmds [as 别名]
# 或者: from maya.cmds import spaceLocator [as 别名]
def test_create(self):
        loc1 = cmds.spaceLocator()[0]
        node = rbf.RBF.create(
            inputs=["{}.t{}".format(loc1, x) for x in "xyz"],
            outputs=["{}.s{}".format(loc1, x) for x in "xyz"],
        )
        inputs = node.inputs()
        self.assertEqual(inputs, ["{}.translate{}".format(loc1, x) for x in "XYZ"])
        outputs = node.outputs()
        self.assertEqual(outputs, ["{}.scale{}".format(loc1, x) for x in "XYZ"])
        node.add_sample(input_values=[5, 4, 6], output_values=[2, 1, 2])
        node.add_sample(input_values=[-5, -6, -4], output_values=[0.5, 2, 3])
        cmds.setAttr("{}.t".format(loc1), 0, 0, 0)
        s = cmds.getAttr("{}.s".format(loc1))[0]
        self.assertListAlmostEqual(s, [1.0, 1.0, 1.0])
        cmds.setAttr("{}.t".format(loc1), 5, 4, 6)
        s = cmds.getAttr("{}.s".format(loc1))[0]
        self.assertListAlmostEqual(s, [2.0, 1.0, 2.0])
        cmds.setAttr("{}.t".format(loc1), -5, -6, -4)
        s = cmds.getAttr("{}.s".format(loc1))[0]
        self.assertListAlmostEqual(s, [0.5, 2.0, 3.0]) 

# 需要导入模块: from maya import cmds [as 别名]
# 或者: from maya.cmds import spaceLocator [as 别名]
def test_create_plot_demo(self):
        loc1 = cmds.spaceLocator()[0]
        node = rbf.RBF.create(
            inputs=["{}.t{}".format(loc1, x) for x in "xy"],
            outputs=["{}.tz".format(loc1)],
            add_neutral_sample=False,
        )
        node.add_sample(input_values=[0, 0], output_values=[1])
        node.add_sample(input_values=[2, 3], output_values=[0.5])
        node.add_sample(input_values=[3, -1], output_values=[1.5])
        node.add_sample(input_values=[-4, -2], output_values=[-1])
        node.add_sample(input_values=[-2, 3], output_values=[2])
        cmds.setAttr("{}.tx".format(loc1), 0)
        cmds.setAttr("{}.ty".format(loc1), 0)
        tz = cmds.getAttr("{}.tz".format(loc1))
        self.assertAlmostEqual(tz, 1.0) 

# 需要导入模块: from maya import cmds [as 别名]
# 或者: from maya.cmds import spaceLocator [as 别名]
def test_input_rotation(self):
        loc1 = cmds.spaceLocator()[0]
        loc2 = cmds.spaceLocator()[0]
        node = rbf.RBF.create(
            input_transforms=[loc1], outputs=["{}.s{}".format(loc2, x) for x in "xyz"]
        )
        input_transforms = node.input_transforms()
        self.assertEqual(input_transforms, [loc1])
        outputs = node.outputs()
        self.assertEqual(outputs, ["{}.scale{}".format(loc2, x) for x in "XYZ"])
        node.add_sample(input_rotations=[[90, 45, 0]], output_values=[2, 1, 2])
        node.add_sample(input_rotations=[[-90, -60, 0]], output_values=[0.5, 2, 3])
        cmds.setAttr("{}.rx".format(loc1), 90)
        cmds.setAttr("{}.ry".format(loc1), 45)
        s = cmds.getAttr("{}.s".format(loc2))[0]
        self.assertListAlmostEqual(s, [2.0, 1.0, 2.0])
        cmds.setAttr("{}.rx".format(loc1), -90)
        cmds.setAttr("{}.ry".format(loc1), -60)
        s = cmds.getAttr("{}.s".format(loc2))[0]
        self.assertListAlmostEqual(s, [0.5, 2.0, 3.0])
        cmds.setAttr("{}.rx".format(loc1), 0)
        cmds.setAttr("{}.ry".format(loc1), 0)
        s = cmds.getAttr("{}.s".format(loc2))[0]
        self.assertListAlmostEqual(s, [1.0, 1.0, 1.0]) 

# 需要导入模块: from maya import cmds [as 别名]
# 或者: from maya.cmds import spaceLocator [as 别名]
def test_opm_point_constraint(self):
        loc1 = cmds.spaceLocator()[0]
        loc2 = cmds.spaceLocator()[0]
        cmds.setAttr("{}.t".format(loc1), 1, 2, 3)
        cmds.setAttr("{}.t".format(loc2), 2, 2, 4)
        common.opm_point_constraint(loc2, loc1)
        m1 = cmds.getAttr("{}.worldMatrix[0]".format(loc1))
        m2 = cmds.getAttr("{}.worldMatrix[0]".format(loc2))
        self.assertListAlmostEqual(m1, m2)
        cmds.setAttr("{}.tx".format(loc2), 5)
        m1 = cmds.getAttr("{}.worldMatrix[0]".format(loc1))
        m2 = cmds.getAttr("{}.worldMatrix[0]".format(loc2))
        self.assertListAlmostEqual(m1, m2)

        cmds.setAttr("{}.rx".format(loc2), 30)
        m1 = cmds.getAttr("{}.worldMatrix[0]".format(loc1))
        self.assertListAlmostEqual(m1, m2) 

# 需要导入模块: from maya import cmds [as 别名]
# 或者: from maya.cmds import spaceLocator [as 别名]
def main(self, objects=None, dummyParent=None, srtDummyParent=None, mode='cut', preSelection=None):
        self.objects = objects
        self.dummyParent = dummyParent
        self.srtDummyParent = srtDummyParent
        self.preSelection = preSelection
        # リストタイプじゃなかったらリストに変換する
        if not isinstance(self.objects, list):
            temp = self.objects
            self.objects = []
            self.objects.append(temp)
        for self.node in self.objects:
            if mode == 'create':
                self.dummyParent = cmds.spaceLocator(name='dummyLocatorForParent')
                return self.dummyParent
            elif mode == 'delete':
                cmds.delete(self.dummyParent)
                return
            elif mode == 'cut':
                self.cutChildNode()
                return
            elif mode == 'custom_cut':
                self.customCutChildNode()
                return
            elif mode == 'parent':
                self.reparentNode()
                return 

# 需要导入模块: from maya import cmds [as 别名]
# 或者: from maya.cmds import spaceLocator [as 别名]
def locator():
    cmds.spaceLocator(p=[0, 0, 0])


# Measure Tools 

# 需要导入模块: from maya import cmds [as 别名]
# 或者: from maya.cmds import spaceLocator [as 别名]
def create_skeleton():
    """
    Create a skeleton hierarchy using the variables provided in the path
    module.

    :return: Skeleton data
    :rtype: dict
    """
    # variable
    joints = {}

    # clear selection
    cmds.select(clear=True)

    # create body
    for body in BODY_HIERARCHY:
        joint = cmds.joint(name="{}_jnt".format(body))
        joints[body] = joint

    # create limbs
    for side in ["l", "r"]:
        cmds.select(joints["hip"])
        for leg in LEG_HIERARCHY:
            joint = cmds.joint(name="{}_{}_jnt".format(side, leg))
            joints["{}_{}".format(side, leg)] = joint

        cmds.select(joints["spine"])
        for arm in ARM_HIERARCHY:
            joint = cmds.joint(name="{}_{}_jnt".format(side, arm))
            joints["{}_{}".format(side, arm)] = joint

    # reference
    reference_name = "reference"
    reference = cmds.spaceLocator(name=reference_name)[0]
    joints["reference"] = reference

    # parent hip to reference
    cmds.parent(joints["hip"], reference)

    return joints 

# 需要导入模块: from maya import cmds [as 别名]
# 或者: from maya.cmds import spaceLocator [as 别名]
def test_input_rotation_swing(self):
        loc1 = cmds.spaceLocator()[0]
        loc2 = cmds.spaceLocator()[0]
        node = rbf.RBF.create(
            input_transforms=[loc1], outputs=["{}.s{}".format(loc2, x) for x in "xyz"]
        )
        node.add_sample(
            input_rotations=[[0, 0, 90]],
            output_values=[2, 1, 2],
            rotation_type=rbf.RBF.swing,
        )
        node.add_sample(
            input_rotations=[[0, 0, -90]],
            output_values=[0.5, 2, 3],
            rotation_type=rbf.RBF.swing,
        )
        cmds.setAttr("{}.rx".format(loc1), 90)
        s = cmds.getAttr("{}.s".format(loc2))[0]
        self.assertListAlmostEqual(s, [1.0, 1.0, 1.0])
        cmds.setAttr("{}.rx".format(loc1), 0)
        cmds.setAttr("{}.rz".format(loc1), 90)
        s = cmds.getAttr("{}.s".format(loc2))[0]
        self.assertListAlmostEqual(s, [2, 1, 2])
        cmds.setAttr("{}.rx".format(loc1), 90)
        s = cmds.getAttr("{}.s".format(loc2))[0]
        self.assertListAlmostEqual(s, [2, 1, 2]) 

# 需要导入模块: from maya import cmds [as 别名]
# 或者: from maya.cmds import spaceLocator [as 别名]
def test_input_rotation_twist(self):
        loc1 = cmds.spaceLocator()[0]
        loc2 = cmds.spaceLocator()[0]
        node = rbf.RBF.create(
            input_transforms=[loc1], outputs=["{}.s{}".format(loc2, x) for x in "xyz"]
        )
        node.add_sample(
            input_rotations=[[90, 0, 0]],
            output_values=[2, 1, 2],
            rotation_type=rbf.RBF.twist,
        )
        node.add_sample(
            input_rotations=[[-90, 0, 0]],
            output_values=[0.5, 2, 3],
            rotation_type=rbf.RBF.twist,
        )
        cmds.setAttr("{}.ry".format(loc1), 90)
        s = cmds.getAttr("{}.s".format(loc2))[0]
        self.assertListAlmostEqual(s, [1.0, 1.0, 1.0])
        cmds.setAttr("{}.ry".format(loc1), 0)
        cmds.setAttr("{}.rx".format(loc1), 90)
        s = cmds.getAttr("{}.s".format(loc2))[0]
        self.assertListAlmostEqual(s, [2, 1, 2])
        cmds.setAttr("{}.rz".format(loc1), 90)
        s = cmds.getAttr("{}.s".format(loc2))[0]
        self.assertListAlmostEqual(s, [2, 1, 2]) 

# 需要导入模块: from maya import cmds [as 别名]
# 或者: from maya.cmds import spaceLocator [as 别名]
def test_opm_parent_constraint(self):
        loc1 = cmds.spaceLocator()[0]
        loc2 = cmds.spaceLocator()[0]
        cmds.setAttr("{}.t".format(loc1), 1, 2, 3)
        cmds.setAttr("{}.t".format(loc2), 2, 2, 4)
        m1 = cmds.getAttr("{}.worldMatrix[0]".format(loc1))
        common.opm_parent_constraint(loc2, loc1, maintain_offset=True)
        m2 = cmds.getAttr("{}.worldMatrix[0]".format(loc1))
        self.assertListAlmostEqual(m1, m2)
        cmds.setAttr("{}.rx".format(loc2), 30)
        m2 = cmds.getAttr("{}.worldMatrix[0]".format(loc1))
        expected = [
            1.0,
            0.0,
            0.0,
            0.0,
            0.0,
            0.8660254037844387,
            0.49999999999999994,
            0.0,
            0.0,
            -0.49999999999999994,
            0.8660254037844387,
            0.0,
            1.0,
            2.5,
            3.133974596215561,
            1.0,
        ]
        self.assertListAlmostEqual(expected, m2) 

# 需要导入模块: from maya import cmds [as 别名]
# 或者: from maya.cmds import spaceLocator [as 别名]
def test_add(self):
        loc = cmds.spaceLocator()[0]
        result = dge("x+3.5", x="{}.tx".format(loc))
        cmds.connectAttr(result, "{}.ty".format(loc))
        cmds.setAttr("{}.tx".format(loc), 5)
        y = cmds.getAttr("{}.ty".format(loc))
        self.assertAlmostEquals(y, 8.5) 

# 需要导入模块: from maya import cmds [as 别名]
# 或者: from maya.cmds import spaceLocator [as 别名]
def test_add_3_to_1(self):
        loc = cmds.spaceLocator()[0]
        result = dge("x+3", x="{}.t".format(loc))
        cmds.connectAttr(result, "{}.r".format(loc))
        cmds.setAttr("{}.tx".format(loc), 5)
        y = cmds.getAttr("{}.rx".format(loc))
        self.assertAlmostEquals(y, 8.0, places=6) 

# 需要导入模块: from maya import cmds [as 别名]
# 或者: from maya.cmds import spaceLocator [as 别名]
def test_add_1_to_3(self):
        loc = cmds.spaceLocator()[0]
        result = dge("3+x", x="{}.t".format(loc))
        cmds.connectAttr(result, "{}.r".format(loc))
        cmds.setAttr("{}.tx".format(loc), 5)
        y = cmds.getAttr("{}.rx".format(loc))
        self.assertAlmostEquals(y, 8.0, places=6)