def test_mobj(self):
""" Test mobj creation & retrieving """
# Test MObject creation
test_node_mobj = om_util.get_mobj(self.test_node)
self.assertEqual(type(test_node_mobj), OpenMaya.MObject)
self.assertEqual(type(om_util.get_mobj(test_node_mobj)),
OpenMaya.MObject)
# Test name retrieving of MObjects
self.assertEqual(om_util.get_name_of_mobj(test_node_mobj),
self.node_name)
self.assertEqual(
om_util.get_dag_path_of_mobj(test_node_mobj, full=False),
self.node_name)
self.assertEqual(
om_util.get_dag_path_of_mobj(test_node_mobj, full=True),
"|{}|{}".format(self.group_name, self.node_name))
# Test renaming of MObjects
om_util.rename_mobj(test_node_mobj, self.node_alt_name)
self.assertEqual(om_util.get_name_of_mobj(test_node_mobj),
self.node_alt_name)
om_util.rename_mobj(test_node_mobj, self.node_name)
# Test MObject selection and retrieving of selection
om_util.select_mobjs(test_node_mobj)
self.assertEqual(cmds.ls(selection=True), [self.node_name])
selected_mobjs = om_util.get_selected_nodes_as_mobjs()
self.assertEqual(len(selected_mobjs), 1)
self.assertEqual(om_util.get_name_of_mobj(selected_mobjs[0]),
self.node_name)
def test_mdag_path(self):
""" Test mdag path creation & retrieving """
test_node_mobj = om_util.get_mobj(self.test_node)
mdag_path = om_util.get_mdag_path(test_node_mobj)
self.assertEqual(type(mdag_path), OpenMaya.MDagPath)
self.assertEqual(str(mdag_path), self.node_name)
def test_aliased_attrs(self):
""" """
test_node_mobj = om_util.get_mobj(self.test_node)
# Make sure regular (custom) attributes are accessible
normal_plug = om_util.get_mplug_of_mobj(test_node_mobj,
self.long_name_attr)
self.assertEqual(type(normal_plug), OpenMaya.MPlug)
self.assertEqual(str(normal_plug),
"{}.{}".format(self.test_node, self.long_name_attr))
# Check whether an aliased attribute is accessible
aliased_plug = om_util.get_mplug_of_mobj(test_node_mobj,
self.aliased_attr)
self.assertEqual(type(aliased_plug), OpenMaya.MPlug)
self.assertEqual(str(aliased_plug),
"{}.{}".format(self.test_node, self.aliased_attr))
# Check whether an aliased attribute can still be found via its actual name as well.
aliased_orig_plug = om_util.get_mplug_of_mobj(test_node_mobj,
self.aliased_attr_orig)
self.assertEqual(type(aliased_orig_plug), OpenMaya.MPlug)
self.assertEqual(str(aliased_orig_plug),
"{}.{}".format(self.test_node, self.aliased_attr))
# Check whether an attribute that doesn't exist returns None.
bogus_plug = om_util.get_mplug_of_mobj(test_node_mobj, "someBogusName")
self.assertIsNone(bogus_plug)
def test_shape(self):
""" Test shape creation & retrieving """
test_node_mobj = om_util.get_mobj(self.test_node)
shape_mobjs = om_util.get_shape_mobjs(test_node_mobj)
self.assertEqual(len(shape_mobjs), 2)
shape_mobj_name = om_util.get_name_of_mobj(shape_mobjs[0])
self.assertEqual(shape_mobj_name, "{}Shape".format(self.node_name))
def test_speed(self):
"""Test speed advantage of om_util functions over cmds equivalent"""
# TODO: Write speed tests
num_iterations = 1000
node = self.test_node
mobj = om_util.get_mobj(self.test_node)
# Test speed of get_parent
def maya_get_parent():
return cmds.listRelatives(node, parent=True)[0]
def noca_get_parent():
return om_util.get_parent(mobj)
self.assertEqual(maya_get_parent(), noca_get_parent())
maya_time = timeit.timeit(maya_get_parent, number=num_iterations)
noca_time = timeit.timeit(noca_get_parent, number=num_iterations)
self.assertLess(noca_time, maya_time)
# Test speed of get_parents
def maya_get_parents():
return cmds.listRelatives(node, allParents=True)
def noca_get_parents():
return om_util.get_parents(mobj)
self.assertEqual(maya_get_parents(), noca_get_parents())
maya_time = timeit.timeit(maya_get_parents, number=num_iterations)
noca_time = timeit.timeit(noca_get_parents, number=num_iterations)
self.assertLess(noca_time, maya_time)
# Test speed of get_dag_path_of_mobj
def maya_get_dag_path():
return cmds.ls(node, long=True)
def noca_get_dag_path():
return om_util.get_dag_path_of_mobj(mobj, full=True)
self.assertEqual(maya_get_dag_path()[0], noca_get_dag_path())
maya_time = timeit.timeit(maya_get_dag_path, number=num_iterations)
noca_time = timeit.timeit(noca_get_dag_path, number=num_iterations)
self.assertLess(noca_time, maya_time)
# Test speed of get_node_type
def maya_get_node_type():
return cmds.objectType(node)
def noca_get_node_type():
return om_util.get_node_type(mobj, api_type=False)
self.assertEqual(maya_get_node_type(), noca_get_node_type())
maya_time = timeit.timeit(maya_get_node_type, number=num_iterations)
noca_time = timeit.timeit(noca_get_node_type, number=num_iterations)
self.assertLess(noca_time, maya_time)
def test_foster_child_attrs(self):
""" """
ramp_name = "testRamp"
attr_name = "colorEntryList[0].colorR"
test_node_mobj = om_util.get_mobj(cmds.createNode("ramp", name=ramp_name))
plug = om_util.get_mplug_of_node_and_attr(
node=test_node_mobj,
attr_str=attr_name,
)
self.assertIsInstance(plug, OpenMaya.MPlug)
self.assertEqual(str(plug), "{}.{}".format(ramp_name, attr_name))
def test_aliased_indexed_attrs(self):
""" """
test_node_mobj = om_util.get_mobj(self.test_node)
duplicate_name = "duplicate_node"
duplicate_node = cmds.duplicate(self.test_node, name=duplicate_name)[0]
blendshape = cmds.blendShape(duplicate_node, self.test_node, name="test_blendShape")[0]
plug = om_util.get_mplug_of_node_and_attr(
node=blendshape,
attr_str=duplicate_name,
)
self.assertIsInstance(plug, OpenMaya.MPlug)
self.assertEqual(str(plug), "{}.{}".format(blendshape, duplicate_name))
def test_plug(self):
""" """
test_node_mobj = om_util.get_mobj(self.test_node)
operator_mobj = om_util.get_mobj(self.test_operator)
transform_attr = "translateX"
parent_attr = "input3D"
array_attr = "{}[0]".format(parent_attr)
child_attr = "input3Dx"
test_value = 7
# Test getting an mplug from a plug
mplug = om_util.get_mplug_of_plug("{}.{}".format(
self.test_operator, array_attr))
self.assertEqual(type(mplug), OpenMaya.MPlug)
self.assertEqual(str(mplug), "{}.{}".format(self.test_operator,
array_attr))
mplug = om_util.get_mplug_of_node_and_attr(self.test_operator,
array_attr)
self.assertEqual(type(mplug), OpenMaya.MPlug)
self.assertEqual(str(mplug), "{}.{}".format(self.test_operator,
array_attr))
self.assertEqual(om_util.is_valid_mplug(mplug), True)
# Test attribute setting and getting
om_util.set_mobj_attribute(test_node_mobj, transform_attr, test_value)
queried_val = cmds.getAttr("{}.{}".format(self.test_node,
transform_attr))
self.assertEqual(queried_val, test_value)
self.assertEqual(
om_util.get_attr_of_mobj(test_node_mobj, transform_attr),
queried_val)
# Test mplug query
parent_plug = om_util.get_mplug_of_mobj(operator_mobj, parent_attr)
self.assertEqual(type(parent_plug), OpenMaya.MPlug)
self.assertEqual(str(parent_plug),
"{}.{}".format(self.test_operator, parent_attr))
# Test array attribute access
array_mplug_elements = om_util.get_array_mplug_elements(parent_plug)
array_mplug_elements_as_str = [
str(var) for var in array_mplug_elements
]
expected_array_plugs = [
"{}.{}[{}]".format(self.test_operator, parent_attr, var)
for var in [0, 3]
]
self.assertEqual(array_mplug_elements_as_str, expected_array_plugs)
# Test array mplug access via pysical index
mplug_by_index = str(
om_util.get_array_mplug_by_index(parent_plug, 0, physical=True))
expected_plug = "{}.{}[0]".format(self.test_operator, parent_attr)
self.assertEqual(mplug_by_index, expected_plug)
mplug_by_index = str(
om_util.get_array_mplug_by_index(parent_plug, 1, physical=True))
expected_plug = "{}.{}[3]".format(self.test_operator, parent_attr)
self.assertEqual(mplug_by_index, expected_plug)
mplug_by_index = om_util.get_array_mplug_by_index(parent_plug,
2,
physical=True)
expected_plug = None
self.assertEqual(mplug_by_index, expected_plug)
# Test array mplug access via logical index
mplug_by_index = str(
om_util.get_array_mplug_by_index(parent_plug, 0, physical=False))
expected_plug = "{}.{}[0]".format(self.test_operator, parent_attr)
self.assertEqual(mplug_by_index, expected_plug)
mplug_by_index = str(
om_util.get_array_mplug_by_index(parent_plug, 1, physical=False))
expected_plug = "{}.{}[1]".format(self.test_operator, parent_attr)
self.assertEqual(mplug_by_index, expected_plug)
mplug_by_index = str(
om_util.get_array_mplug_by_index(parent_plug, 3, physical=False))
expected_plug = "{}.{}[3]".format(self.test_operator, parent_attr)
self.assertEqual(mplug_by_index, expected_plug)
# Test child attribute access
child_mplug = om_util.get_child_mplug(mplug, child_attr)
expected_child_plug = "{}.{}.{}".format(self.test_operator, array_attr,
child_attr)
self.assertEqual(str(child_mplug), expected_child_plug)
# Test parent attribute access
parent_mplug = om_util.get_parent_mplug(child_mplug)
self.assertEqual(str(parent_mplug),
"{}.{}".format(self.test_operator, array_attr))
# Test children attributes access
child_mplugs = om_util.get_child_mplugs(parent_mplug)
expected_child_plugs = [
"{}.{}.input3D{}".format(self.test_operator, array_attr, var)
for var in "xyz"
]
self.assertEqual([str(var) for var in child_mplugs],
expected_child_plugs)
