code_gallery

Web News Blog Press Pricing

Learn

Training

Profiles

Executive

Templates

VFX

Code

Code Gallery Designer

v5.20

Maya

Load Cameras

Luis Miguel 31/10/2024

Tags
maya camera td

Load Cameras

Luis Miguel

Action v1

31/10/2024

Maya

Pseudo-Code

282	read the maintask key from store in case the action is in a logic or callback.
284	If the action is not in a logic/callback use a default maintask_key
285	Get all the cameras (last version) for the current file.
287	Load each camera file.

Parameters

maintask_key

The maintrask_key to read the cameras from. In a callback or logic can be added and selected under the task and recived in the store. For actions in the Kraken shelf, paste the key in the code.

Talk with TD Support

Import to my Pipeline

Code

print('Loading Tracking Camera...')
import maya.cmds as cmds
import pipeline
import os

def import_camera(file_path):
    """Imports the cameras from the file in Maya
    
    Args:
        file_path str: The path to the camera file.
        
    Returns:
        list: The imported cameras.
    """
    if not os.path.exists(file_path):
        cmds.warning("The file does not exists: " + file_path)
        return
    ext = os.path.splitext(file_path)[-1].lower()
    pre_cameras = cmds.ls(type="camera")
    if ext == ".abc":
        cmds.AbcImport(file_path, mode="import")
    elif ext == ".fbx":
        cmds.file(file_path, i=True, type="FBX", 
                  mergeNamespacesOnClash=False, ignoreVersion=True)
    else:
        cmds.warning(f"Camera format file '{ext}' not supported. "
                     "Action only supports .abc or .fbx")
        return
    # Find imported camera
    cameras = cmds.ls(type="camera")
    imported_cameras = [cam for cam in cameras if not cmds.referenceQuery(
        cam, isNodeReferenced=True)]
    imported_cameras = [cam for cam in imported_cameras if cam not in pre_cameras]

if not imported_cameras:
        cmds.warning(f"No cameras imported from: {file_path}.")
        return
    return imported_cameras

def create_camera():
    """Creates an empty camera.
    
    Returns:
        list: The camera shape names.
    """
    # New camera
    group = cmds.group(em=True, name="default_camera_grp")
    camera_transform = cmds.createNode("transform", name="TrackingCamera", 
                                       parent=group)
    camera_shape = cmds.createNode("camera", name="TrackingCameraShape", 
                                   parent=camera_transform)

# Basic config
    cmds.setAttr(f"{camera_shape}.focalLength", 35)
    cmds.setAttr(f"{camera_shape}.nearClipPlane", 0.1)
    cmds.setAttr(f"{camera_shape}.farClipPlane", 10000)
    cmds.setAttr(f"{camera_shape}.renderable", 1)

print(f"New camera '{camera_transform}' created successfully.")
    return [camera_shape]

def import_or_create_camera(filepath=None):
    """Imports or create a camera from a file.
    
    Args:
        filepath str: The path to the camera file. (Default=None)
    """
    # Create default groups
    tracking_group = "Cameras|Tracking"
    if not cmds.objExists("Cameras"):
        cmds.group(em=True, name="Cameras")
    if not cmds.objExists(tracking_group):
        tracking_group = cmds.group(em=True, name="Tracking", parent="Cameras")

if not filepath or not os.path.exists(filepath):
        cmds.warning(f"File does not exist: {filepath}. Creating a new camera instead.")
        imported_cameras = create_camera()
    else:
        imported_cameras = import_camera(filepath)
        if not imported_cameras:
            cmds.warning(f"No cameras imported from: {filepath}.")
            return
    print(f"Loaded cameras: {imported_cameras}")
    # TODO define what to do if more that 1 camera is imported
    camera_shape = imported_cameras[0]
    camera_transform = cmds.listRelatives(camera_shape, parent=True, fullPath=True)[0]
    camera_grp = cmds.listRelatives(camera_transform, parent=True, fullPath=True)[0]
    # Rename group
    new_grp_name = f"{camera_transform.split('|')[-1]}_grp"
    cmds.rename(camera_grp, new_grp_name)
    # Move camera to group "Cameras/Tracking"
    cmds.parent(new_grp_name, tracking_group)
    print(f"Camera '{camera_transform}' loaded successfully.")
    
    # Disable default render camera
    if cmds.objExists("perspShape"):
        cmds.setAttr("perspShape.renderable", 0)
        print("Camera 'persp' is now non-renderable.")

def exec_query(query):
    """Execs a query to get data from the platform.
    
    Args:
        query str: The query to execute.
        
    Returns:
        dict: The query response.
    """
    if query.find("token:") < 0:
        print("Warning: The token key is not included in" 
               "the query, it will probably fail.")
    try:
        response = pipeline.query(query)
    except Exception as e:
        print("Error on DB query: ", e)
        return
    return response
    
def get_shot_key(filename):
    """Gets the key of the shot linked to the file.
    
    Args:
        filename str: the filename to query.
        
    Returns:
        str: The shot key.
    """
    query = '''
    query {
        file(fileName: "{filename}", token:"{token}"){
          fileName
          folder{
            code
            relTaskFolder{
              code
              relShotTask{
                code
                key
              }
            }
          }
        }
      }
    '''
    query = query.replace("{filename}", filename)
    response = exec_query(query)
    if not response:
        return
    tasks = response["file"]["folder"]["relTaskFolder"]
    if not tasks:
        print(f"Error: No tasks found linked to the folder "
              f"'{response['file']['folder']['code']}' of file "
              f"'{response['file']['fileName']}'.")
        return
    shots = tasks[0]['relShotTask']
    if not shots:
        print(f"Error: No shots found linked to the task '{tasks[0]['code']}'.")
        return
    shot = shots[0]
    return shot['key']

def get_shot_task(shot_key, maintask_key, attrs=[]):
    """Gets the task of an specific maintask type for a shot.
    
    Args:
        shot_key str: The shot key.
        maintask_key: the maintask_key.
        attrs list: The list of attributes to get. (Default=[])
    
    Returns:
        dict: The task data.
    """
    query = '''
    query{
      task(maintask:"{maintask}", shotKey:"{shotKey}", token:"{token}") {
        name
        key
      }
    }
    '''
    query = query.replace("{maintask}", maintask_key)
    query = query.replace("{shotKey}", shot_key)
    # TODO add support for custom attributes in the query
    response = exec_query(query)
    if not response:
        return
    task = response['task']
    return task

def get_last_folder_from_task(task_key, folder='render'):
    """Get the last folder of an specific type for a task.
    
    Args:
        task_key str: The key of the task.
        folder str: The folder type to get.
        
    Returns:
        dict: The folder data.
    """
    query = '''
    query{
      lastFolderByTask(taskKey:"{taskKey}", type:"{folder_type}", token:"{token}"){
        folderLocal
        review
        wip
        files{
          fileName
        }
      }
    }
    '''
    query = query.replace("{taskKey}", task_key)
    query = query.replace("{folder_type}", folder)
    response = exec_query(query)
    if not response:
        return
    folder = response['lastFolderByTask']
    return folder

def get_last_task_folder_from_file(filename, maintask_key, folder='render'):
    """Get kast folder of an especific type for a maintask type given a filename.
    
    Args:
        filename str: The name of the file.
        maintask_key str: The task type to get from the shot.
        folder str: The folder type to get the last from. (Default='render')
        
    Returns:
        dict: The folder data.
    """
    shot_key = get_shot_key(filename)
    if not shot_key:
        return
    task = get_shot_task(shot_key, maintask_key)
    if not task:
        return
    folder = get_last_folder_from_task(task['key'], folder=folder)
    return folder

def get_cameras_from_folder(folder):
    """Get the cameras to import from a folder.
    
    Args:
        folder str: The folder type name.
        
    Returns:
        list: The camera file paths.
    """
    cameras = []
    
    for f in folder['files']:
        cam_path = os.path.normpath(os.path.join(
            folder['folderLocal'],
            f['fileName']
        ))
        cameras.append(cam_path)
    
    return cameras

def get_last_cam_current_file(maintask_key):
    """Get the cameras to import from a maintask.
    
    Args:
        maintask_key str: The maintask to get the camera from.
        
    Returns:
        list: The camera file paths.
    """
    filepath = cmds.file(q=True, sn=True)
    filename = os.path.basename(filepath)
    folder = get_last_task_folder_from_file(filename, 
                                            maintask_key, 
                                            folder='cameras')
    if not folder:
        return []
    cameras = get_cameras_from_folder(folder)
    return cameras

# Store
try:  # Get maintask key from state action if the action is in a logic/callback
    maintask_key = store["state_action_list"][0]["maintask"]
except:  # Set default maintask to allow execution from Kraken actions shelf
    maintask_key = ""
cameras = get_last_cam_current_file(maintask_key)
for cam in cameras:
    import_or_create_camera(filepath=cam)
print('Cameras loading successfully.')

Import Action

1. Copy Key

Copy

2. Go to your Action pannel

Go