def test_init(self):
x = bundle.Bundle()
x_node = x.get_node()
self.assertEqual(x_node, None)
# Create nodes
y = bundle.Bundle().create_node()
y_node = y.get_node()
y_obj_type = api_utils.get_object_type(y_node)
self.assertTrue(maya.cmds.objExists(y_node))
self.assertEqual(y_node, '|bundle1')
self.assertEqual(y_obj_type, const.OBJECT_TYPE_BUNDLE)
# Create nodes (again, with explicit node name)
y = bundle.Bundle().create_node(name='myBundle1')
y_node = y.get_node()
y_obj_type = api_utils.get_object_type(y_node)
self.assertTrue(maya.cmds.objExists(y_node))
self.assertEqual(y_node, '|myBundle1')
self.assertEqual(y_obj_type, const.OBJECT_TYPE_BUNDLE)
# Set Node via __init__
z = bundle.Bundle(node=y_node)
z_node = z.get_node()
z_obj_type = api_utils.get_object_type(z_node)
self.assertEqual(z_node, y_node)
self.assertEqual(z_node, '|myBundle1')
self.assertEqual(z_obj_type, const.OBJECT_TYPE_BUNDLE)
# Set Node via set_node
x.set_node(y_node)
x_node = x.get_node()
x_obj_type = api_utils.get_object_type(x_node)
self.assertEqual(x_node, y_node)
self.assertEqual(x_obj_type, const.OBJECT_TYPE_BUNDLE)
def test_init(self):
x = bundle.Bundle()
x_node = x.get_node()
self.assertEqual(x_node, None)
# Create nodes
y = bundle.Bundle().create_node()
y_node = y.get_node()
self.assertTrue(maya.cmds.objExists(y_node))
self.assertEqual(y_node, '|bundle1')
# Create nodes (again, with explicit node name)
y = bundle.Bundle().create_node(name='myBundle1')
y_node = y.get_node()
self.assertTrue(maya.cmds.objExists(y_node))
self.assertEqual(y_node, '|myBundle1')
# Set Node via __init__
z = bundle.Bundle(node=y_node)
z_node = z.get_node()
self.assertEqual(z_node, y_node)
self.assertEqual(z_node, '|myBundle1')
# Set Node via set_node
x.set_node(y_node)
x_node = x.get_node()
self.assertEqual(x_node, y_node)
def test_is_valid(self):
"""
Collection validation.
Once all pieces are connected, the collection is valid.
"""
x = collection.Collection()
x.create_node('myCollection')
self.assertFalse(x.is_valid())
# Solver
sol = solver.Solver()
x.add_solver(sol)
self.assertFalse(x.is_valid())
# Solver (with frame)
f = frame.Frame(1)
sol.add_frame(f)
self.assertFalse(x.is_valid())
# Marker / Bundle
cam_tfm = maya.cmds.createNode('transform', name='camera1')
cam_shp = maya.cmds.createNode('camera', name='cameraShape1')
cam = camera.Camera(shape=cam_shp)
bnd = bundle.Bundle().create_node()
mkr = marker.Marker().create_node(cam=cam, bnd=bnd)
x.add_marker(mkr)
self.assertFalse(x.is_valid())
# Attribute
node = bnd.get_node()
attr = attribute.Attribute(node=node, attr='translateX')
x.add_attribute(attr)
self.assertTrue(x.is_valid())
def test_get_marker_list(self):
x = bundle.Bundle().create_node(name='myBundle1')
mkr_list1 = x.get_marker_list()
self.assertEqual(len(mkr_list1), 0)
for i in xrange(10):
mkr = marker.Marker().create_node()
mkr.set_bundle(x)
mkr_list2 = x.get_marker_list()
self.assertEqual(len(mkr_list2), 10)
def test_get_bundle(self):
x = marker.Marker().create_node()
bnd0 = x.get_bundle()
self.assertEqual(bnd0, None)
bnd1 = bundle.Bundle().create_node()
x.set_bundle(bnd1)
bnd2 = x.get_bundle()
self.assertEqual(bnd1.get_node(), bnd2.get_node())
def test_set_colour_rgb(self):
"""
Set wireframe colour of the bundle.
"""
green = (0.0, 1.0, 0.0)
blue = (0.0, 0.0, 1.0)
x = bundle.Bundle()
x_rgb = x.get_colour_rgb()
self.assertEqual(x_rgb, None)
# Create nodes
y = bundle.Bundle().create_node(name='myBundle1')
y_rgb = y.get_colour_rgb()
self.assertEqual(y_rgb, green)
y.set_colour_rgb(blue)
y_rgb = y.get_colour_rgb()
self.assertEqual(y_rgb, blue)
return
def test_create_node(self):
# TODO: Add undo/redo tests.
x = marker.Marker()
x.create_node()
node = x.get_node()
self.assertIsInstance(node, (str, unicode))
self.assertTrue(maya.cmds.objExists(node))
x = marker.Marker().create_node()
node = x.get_node()
self.assertIsInstance(node, (str, unicode))
self.assertTrue(maya.cmds.objExists(node))
name = 'myMarker1'
x = marker.Marker().create_node(name=name)
node = x.get_node()
self.assertTrue(maya.cmds.objExists(node))
self.assertEqual(x.get_camera(), None)
cam = self.create_camera('myCamera1')
cam_tfm = cam.get_transform_node()
cam_shp = cam.get_shape_node()
# Create marker linked to camera
x = marker.Marker().create_node(name=name, cam=cam)
node = x.get_node()
mkr_cam = x.get_camera()
self.assertTrue(maya.cmds.objExists(node))
self.assertEqual(mkr_cam.get_shape_node(), cam_shp)
# Create a Bundle.
bnd = bundle.Bundle().create_node()
bnd_node = bnd.get_node()
# Create marker linked to bundle
x = marker.Marker().create_node(name=name, bnd=bnd)
node = x.get_node()
mkr_bnd = x.get_bundle()
self.assertTrue(maya.cmds.objExists(node))
self.assertEqual(mkr_bnd.get_node(), bnd_node)
# Create marker linked to camera and bundle
x = marker.Marker().create_node(name=name, cam=cam, bnd=bnd)
node = x.get_node()
self.assertTrue(maya.cmds.objExists(node))
mkr_cam = x.get_camera()
mkr_bnd = x.get_bundle()
self.assertEqual(mkr_cam.get_shape_node(), cam_shp)
self.assertEqual(mkr_bnd.get_node(), bnd_node)
def test_set_bundle(self):
x = marker.Marker().create_node()
bnd0 = x.get_bundle()
self.assertEqual(bnd0, None)
bnd1 = bundle.Bundle().create_node()
x.set_bundle(bnd1) # link marker to bundle
bnd2 = x.get_bundle()
self.assertEqual(bnd1.get_node(), bnd2.get_node())
x.set_bundle(None) # unlink bundle from marker
bnd3 = x.get_bundle()
self.assertEqual(bnd3, None)
self.assertNotEqual(bnd1.get_node(), bnd3)
def get_marker_nodes_from_bundle_nodes(nodes):
"""
:param nodes:
:type nodes:
:return:
:rtype:
"""
bnd_nodes = nodefilter.filter_bundle_nodes(nodes)
mkr_nodes = []
for bnd_node in bnd_nodes:
bnd = bundle.Bundle(bnd_node)
mkr_list = bnd.get_marker_list()
for mkr in mkr_list:
mkr_node = mkr.get_node()
if mkr_node not in mkr_nodes:
mkr_nodes.append(mkr_node)
return mkr_nodes
def get_marker_nodes_from_bundle_nodes(nodes):
"""
Get a list of marker nodes from the given list of bundle nodes
Bundle nodes are automatically filtered from the given 'nodes'.
:param nodes: Candidates for bundle nodes to search with.
:type nodes: [str, ..]
:return: List of marker nodes attached to the given bundle nodes.
:rtype: [str, ..]
"""
bnd_nodes = nodefilter.filter_bundle_nodes(nodes)
mkr_nodes = []
for bnd_node in bnd_nodes:
bnd = bundle.Bundle(bnd_node)
mkr_list = bnd.get_marker_list()
for mkr in mkr_list:
mkr_node = mkr.get_node()
if mkr_node not in mkr_nodes:
mkr_nodes.append(mkr_node)
return mkr_nodes
def compile(self, col, mkr_list, attr_list, withtest=False):
actions = []
# TODO: Triangulate the (open) bundles here. We triangulate all
# valid bundles after the root frames have solved.
#
# NOTE: Bundle triangulation can only happen if the camera
# is not nodal.
#
# NOTE: We currently assume the camera is NOT nodal.
valid_bnd_node_list = []
for mkr in mkr_list:
bnd = mkr.get_bundle()
bnd_node = bnd.get_node()
valid_bnd_node_list.append(bnd_node)
valid_node_list = collections.defaultdict(int)
for attr in attr_list:
assert isinstance(attr, attribute.Attribute) is True
attr_name = attr.get_attr()
if attr_name not in BUNDLE_ATTR_NAMES:
continue
attr_node = attr.get_node()
if attr_node not in valid_bnd_node_list:
continue
obj_type = api_utils.get_object_type(attr_node)
if obj_type == const.OBJECT_TYPE_BUNDLE:
valid_node_list[attr_node] += 1
for node, count in valid_node_list.items():
if count != 3:
continue
bnd = bundle.Bundle(node=node)
bnd_node = bnd.get_node()
mkr_node_list = [x.get_node() for x in mkr_list]
bnd_mkr_list = [x for x in bnd.get_marker_list()
if x.get_node() in mkr_node_list]
bnd_mkr_node_list = [x.get_node() for x in bnd_mkr_list]
bnd_cam_node_list = [x.get_camera().get_transform_node()
for x in bnd_mkr_list]
bnd_mkr_frm_list = [_get_marker_first_last_frame_list(x, self.root_frame_list)
for x in bnd_mkr_node_list]
bnd_mkr_cam_frm_list = zip(
bnd_mkr_node_list,
bnd_cam_node_list,
bnd_mkr_frm_list
)
# TODO: We must detect if the newly calculated position is
# behind the camera, if so, we reject the new values.
args = [bnd_node, bnd_mkr_cam_frm_list]
kwargs = {}
action = api_action.Action(
_triangulate_bundle,
args=args,
kwargs=kwargs
)
LOG.debug('adding _triangulate_bundle: func=%r',
_triangulate_bundle,
args,
kwargs
)
# actions.append(action)
yield action, None
return
