code_gallery

Web News Blog Press Pricing

Learn

Training

Templates

VFX

Code

Code Gallery Designer

v5.09

Maya

Load Plates

Luis Miguel 31/10/2024

Tags
maya vfx td

Load Plates

Luis Miguel

Action v1

31/10/2024

Maya

Pseudo-Code

140	Get the plates to load
143	Format the path for each video file.
147	Get the camera for an especific plate
149	Create an imageplane and assign it to the camera.

Parameters

-	Have plate cameras created in the maya scene

Talk with TD Support

Import to my Pipeline

Code

import maya.cmds as cmds
import os
import pipeline
import ast

def get_shot_plates_data():
    """Returns a dict with all the plates and the path and frame range of each.
    
    Returns:
        list: Plates dictionaries with the data of each one.
    """
    plates = []
    
    query = """
        query {
        file(fileName: "{filename}", token:"{token}"){
          folder {
            relTaskFolder{
              relShotTask{
                shot,
                data
              }
            }
          }
        }
      }
    """
    filepath = cmds.file(q=True, sn=True)
    filename = os.path.basename(filepath)
    query = query.replace("{filename}", filename)
    try:
        response = pipeline.query(query)
    except Exception as e:
        print("Error on DB query: ", e)
        return plates
    file_props = response["file"]["folder"]["relTaskFolder"][0]["relShotTask"][0]["data"]
    if not file_props:
        # No plates versions published yet
        print(f"Warning: No plates versions published yet.")
        return plates
    plate_props = ast.literal_eval(file_props).get("plates_data", [])
    if type(plate_props) == str:
        plate_props = ast.literal_eval(plate_props)
    # For each plate in the shot data
    for plate, plateVersionList in plate_props.items():
        if not plateVersionList:
            print(f"Plate {plate} do not have version published yet. Skipping...")
            continue
        plateData = plateVersionList[-1]
        plate_data = {
            "plate": plate,
            "version": plateData["version"],
            "path": plateData["path"],
            "start": plateData["start"],
            "end": plateData["end"],
            "colorspace": plateData["colorspace"],
            "effect_nodes": plateData["effect_nodes"]
        }
        plates.append(plate_data)
    return plates

def get_tracking_camera(plate):
    """Look for a camera in 'Cameras|Tracking'.
    
    Args:
        plate str: the name of the plate.
        
    Returns:
        str: The full name of the camera group.
    """
    tracking_group = "Cameras|Tracking"

if not cmds.objExists(tracking_group):
        cmds.warning("No 'Cameras|Tracking' group found in the scene.")
        return None
    cam_grp = f"cam_{plate}_grp"
    cam_grp_full = f"{tracking_group}|{cam_grp}"
    # Check connections
    if not cmds.objExists(cam_grp_full):
        cmds.warning(f"No {cam_grp_full} group found in the scene.")
        return None

transforms = cmds.listRelatives(cam_grp_full, children=True, 
                                    type="transform", fullPath=True)
    if not transforms:
        return
    shapes = cmds.listRelatives(transforms[0], shapes=True, type="camera", fullPath=True)
    if shapes:
        return cam_grp_full
    
    cmds.warning(f"No cameras found inside 'Cameras|Tracking' for plate '{plate}'.")
    return None

def assign_imageplane_to_camera(camera_grp, video_path):
    """Asign an imageplane to the camera with the given video.
    
    Args:
        camera_grp str: The name of the camera group.
        video_path str: The path to the video to load like image plane.
    """
    cameras = cmds.listRelatives(camera_grp, children=True, 
                                 type="transform", fullPath=True)
    if not cameras:
        return
    camera = cameras[0]
    # Get camera shape
    camera_shape = cmds.listRelatives(camera, shapes=True, type="camera", fullPath=True)[0]
    
    # Check if the camera already have a camera shape
    existing_planes = cmds.listConnections(camera_shape, type="imagePlane") or []
    if existing_planes:
        image_plane = existing_planes[0]
        print(f"Using existing imagePlane: {image_plane}")
    else:
        short_cam = camera.split("|")[-1]
        image_plane_name = f"{short_cam}_Plate"
        # Create a new image plane
        image_transform = cmds.createNode("transform", name=image_plane_name, 
                                       parent=camera_grp)
        image_plane = cmds.createNode("imagePlane", 
                                      name=f"{image_plane_name}_imagePlane", 
                                      parent=image_transform)
        cmds.connectAttr(f"{image_plane}.message", 
                         f"{camera_shape}.imagePlane", 
                         force=True)
        print(f"Created new imagePlane: {image_plane}")

# Define if is an image sequence
    file_ext = os.path.splitext(video_path)[-1].lower()
    is_sequence = file_ext in ['.exr', '.jpg', '.png']

# Asignar archivo al imagePlane
    cmds.setAttr(f"{image_plane}.imageName", video_path, type="string")
    cmds.setAttr(f"{image_plane}.useFrameExtension", int(is_sequence))

print(f"Assigned '{video_path}' to imagePlane '{image_plane}'.")

# -------------------------------
# TODO get plate exr path
plates = get_shot_plates_data()
if plates:
    for plate in plates:
        video_file = plate["path"].replace("%04d", "####")
        if not video_file:
            continue
        # Get camera
        camera = get_tracking_camera(plate["plate"])
        if camera:
            assign_imageplane_to_camera(camera, video_file)
        else:
            cmds.warning("No tracking camera found. Aborting operation.")

Import Action

1. Copy Key

Copy

2. Go to your Action pannel

Go