Center 2D - add support for multi-object and components

This is a long-awaited feature for being able to center on multiple
objects at once, or even components of an object - such as a Mesh
vertex, edge or face.

Using the mmPointFromObjectSet we are able to compute a new point that
the mmReprojection node can use.

Author: david-cattermole

python/mmSolver/tools/centertwodee/tool.py

@@ -80,71 +80,63 @@ def main():
         save_sel = maya.cmds.ls(selection=True, long=True) or []
 
         # Get selection
-        nodes = (
+        objects = (
             maya.cmds.ls(
                 selection=True,
                 long=True,
-                type='transform',
             )
             or []
         )
 
         # Filter out selected imagePlanes.
-        nodes_tmp = list(nodes)
-        nodes = []
-        for node in nodes_tmp:
+        objects_tmp = list(objects)
+        objects = []
+        for obj in objects_tmp:
             shps = (
                 maya.cmds.listRelatives(
-                    node, shapes=True, fullPath=True, type='imagePlane'
+                    obj, shapes=True, fullPath=True, type='imagePlane'
                 )
                 or []
             )
             if len(shps) == 0:
-                nodes.append(node)
+                objects.append(obj)
 
         # Create centering node network.
-        if len(nodes) == 0:
+        if len(objects) == 0:
             msg = 'No objects selected, removing 2D centering.'
             LOG.warning(msg)
             mmapi.load_plugin()
             reproject_utils.remove_reprojection_from_camera(cam_tfm, cam_shp)
             reproject_utils.reset_pan_zoom(cam_tfm, cam_shp)
-        elif len(nodes) == 1:
-            LOG.warning('Applying 2D centering to %r', nodes)
+        else:
+            LOG.warning('Applying 2D centering to %r', objects)
             mmapi.load_plugin()
-            reproj_nodes = reproject_utils.find_reprojection_nodes(cam_tfm, cam_shp)
-            if len(reproj_nodes) > 0:
-                maya.cmds.delete(reproj_nodes)
+            reproject_utils.remove_reprojection_from_camera(cam_tfm, cam_shp)
 
             reproj_node = reproject_utils.create_reprojection_on_camera(
                 cam_tfm, cam_shp
             )
-            reproject_utils.connect_transform_to_reprojection(nodes[0], reproj_node)
+            reproject_utils.connect_objects_to_reprojection(objects, reproj_node)
 
             # create 2d offset setup
             offset_plus_minus_node = maya.cmds.createNode(
                 'plusMinusAverage', name='offset_plusMinusAverage1'
             )
-            maya.cmds.connectAttr(
-                reproj_node + '.outPan', offset_plus_minus_node + '.input2D[0]'
-            )
-            maya.cmds.setAttr(
-                offset_plus_minus_node + '.input2D[1]', 0.0, 0.0, type='float2'
-            )
-            maya.cmds.connectAttr(
-                offset_plus_minus_node + '.output2D.output2Dx',
-                cam_shp + '.pan.horizontalPan',
-                force=True,
-            )
-            maya.cmds.connectAttr(
-                offset_plus_minus_node + '.output2D.output2Dy',
-                cam_shp + '.pan.verticalPan',
-                force=True,
-            )
 
-        elif len(nodes) > 1:
-            msg = 'Please select only 1 node to center on.'
-            LOG.error(msg)
+            src = reproj_node + '.outPan'
+            dst = offset_plus_minus_node + '.input2D[0]'
+            maya.cmds.connectAttr(src, dst)
+
+            plug = offset_plus_minus_node + '.input2D[1]'
+            maya.cmds.setAttr(plug, 0.0, 0.0, type='float2')
+
+            src = offset_plus_minus_node + '.output2D.output2Dx'
+            dst = cam_shp + '.pan.horizontalPan'
+            maya.cmds.connectAttr(src, dst, force=True)
+
+            src = offset_plus_minus_node + '.output2D.output2Dy'
+            dst = cam_shp + '.pan.verticalPan'
+            maya.cmds.connectAttr(src, dst, force=True)
 
         if len(save_sel) > 0:
             maya.cmds.select(save_sel, replace=True)

python/mmSolver/utils/reproject.py

@@ -133,24 +133,62 @@ def create_reprojection_on_camera(cam_tfm, cam_shp):
     return node
 
 
-def find_reprojection_nodes(cam_tfm, cam_shp):
+def _find_auxiliary_set_nodes(point_from_set_node):
     """
     Find all the reprojection nodes on the camera.
     """
-    nodes = (
+    nodes = []
+
+    object_set_nodes = (
         maya.cmds.listConnections(
-            cam_shp + '.focalLength',
-            source=False,
-            destination=True,
-            type='mmReprojection',
+            point_from_set_node + '.set',
+            source=True,
+            destination=False,
+            type='objectSet',
             exactType=True,
             skipConversionNodes=True,
         )
         or []
     )
-    if not nodes:
-        return nodes
-    reprojection_node = nodes[0]
+    nodes += object_set_nodes
+
+    # transform_plugs = (
+    #     maya.cmds.listConnections(
+    #         point_from_set_node + '.matrix',
+    #         source=True,
+    #         destination=False,
+    #         plugs=True,
+    #         type='transform',
+    #         exactType=False,
+    #         skipConversionNodes=True,
+    #     )
+    #     or []
+    # )
+    # # nodes += transform_nodes
+
+    # mesh_plugs = (
+    #     maya.cmds.listConnections(
+    #         point_from_set_node + '.mesh',
+    #         source=True,
+    #         destination=False,
+    #         plugs=True,
+    #         type='mesh',
+    #         exactType=True,
+    #         skipConversionNodes=True,
+    #     )
+    #     or []
+    # )
+    # # nodes += mesh_nodes
+
+    return nodes
+
+
+def _find_auxiliary_reprojection_nodes(reprojection_node):
+    """
+    Find all the reprojection nodes on the camera.
+    """
+    nodes = []
+
     # Get connected MultiplyDivide nodes connected.
     mult_nodes = (
         maya.cmds.listConnections(
@@ -165,6 +203,7 @@ def find_reprojection_nodes(cam_tfm, cam_shp):
         or []
     )
     nodes += mult_nodes
+
     # Get connected offset PlusMinusAverage nodes.
     offset_plusminus_nodes = (
         maya.cmds.listConnections(
@@ -178,6 +217,58 @@ def find_reprojection_nodes(cam_tfm, cam_shp):
         or []
     )
     nodes += offset_plusminus_nodes
+
+    # Get connected mmPointFromObjectSet nodes.
+    point_from_set_nodes = (
+        maya.cmds.listConnections(
+            reprojection_node + '.transformWorldMatrix',
+            source=True,
+            destination=False,
+            type='mmPointFromObjectSet',
+            exactType=True,
+            skipConversionNodes=True,
+        )
+        or []
+    )
+    nodes += point_from_set_nodes
+
+    return nodes
+
+
+def _find_object_set_nodes(reproj_node):
+    reproj_aux_nodes = _find_auxiliary_reprojection_nodes(reproj_node)
+    point_from_set_nodes = [
+        x for x in reproj_aux_nodes if maya.cmds.nodeType(x) == 'mmPointFromObjectSet'
+    ]
+    set_nodes = []
+    for point_from_set_node in point_from_set_nodes:
+        set_nodes += _find_auxiliary_set_nodes(point_from_set_node)
+
+    return list(sorted(set(set_nodes + point_from_set_nodes)))
+
+
+def find_reprojection_nodes(cam_tfm, cam_shp):
+    """
+    Find all the reprojection nodes on the camera.
+    """
+    nodes = (
+        maya.cmds.listConnections(
+            cam_shp + '.focalLength',
+            source=False,
+            destination=True,
+            type='mmReprojection',
+            exactType=True,
+            skipConversionNodes=True,
+        )
+        or []
+    )
+    if not nodes:
+        return nodes
+    reprojection_node = nodes[0]
+
+    # Get the other nodes.
+    nodes += _find_auxiliary_reprojection_nodes(reprojection_node)
+    nodes += _find_object_set_nodes(reprojection_node)
     return nodes
 
 
@@ -215,17 +306,70 @@ def reset_pan_zoom(cam_tfm, cam_shp):
     return
 
 
-def connect_transform_to_reprojection(tfm, reproj):
+def _cleanup_object_set_nodes(reproj_node):
+    old_nodes = _find_object_set_nodes(reproj_node)
+    if len(old_nodes) > 0:
+        maya.cmds.delete(old_nodes)
+    return len(old_nodes)
+
+
+def connect_transform_to_reprojection(tfm, reproj_node):
     """
-    Connect 'tfm' to the reprojection node, 'reproj'.
+    Connect 'tfm' to the reprojection node, 'reproj_node'.
 
     :param tfm: Transform node name to be connected.
     :type tfm: str
 
-    :param reproj: The re-projection node.
-    :type reproj: str
+    :param reproj_node: The re-projection node.
+    :type reproj_node: str
     """
+    _cleanup_object_set_nodes(reproj_node)
+
     src = tfm + '.worldMatrix'
-    dst = reproj + '.transformWorldMatrix'
-    maya.cmds.connectAttr(src, dst)
+    dst = reproj_node + '.transformWorldMatrix'
+    maya.cmds.connectAttr(src, dst, force=True)
+    return
+
+
+def connect_objects_to_reprojection(objects, reproj_node):
+    """
+    Connect all the objects and components in 'objects' to the
+    reprojection node, 'reproj_node'.
+
+    :param objects:
+    :type objects: str
+
+    :param reproj_node: The re-projection node.
+    :type reproj_node: str
+
+    """
+    _cleanup_object_set_nodes(reproj_node)
+
+    point_from_set_node = maya.cmds.createNode('mmPointFromObjectSet')
+    set_node = maya.cmds.sets(objects, name=reproj_node + '_center_objectSet')
+    maya.cmds.connectAttr(
+        set_node + '.message', point_from_set_node + '.set', force=True
+    )
+
+    nodes = maya.cmds.ls(objects, objectsOnly=True, long=True)
+    for i, node in enumerate(nodes):
+        if not node.startswith('|'):
+            # Only DAG objects can be connected.
+            continue
+
+        # Both shapes and transforms should always contain a
+        # worldMatrix attribute.
+        src = node + '.worldMatrix[0]'
+        dst = point_from_set_node + '.matrix[{}]'.format(i)
+        maya.cmds.connectAttr(src, dst, force=True)
+
+        node_type = maya.cmds.nodeType(node)
+        if node_type == 'mesh':
+            src = node + '.worldMesh[0]'
+            dst = point_from_set_node + '.mesh[{}]'.format(i)
+            maya.cmds.connectAttr(src, dst, force=True)
+
+    src = point_from_set_node + '.outMatrix'
+    dst = reproj_node + '.transformWorldMatrix'
+    maya.cmds.connectAttr(src, dst, force=True)
     return