code_gallery

Web News Blog Press Pricing

Learn

Training

Profiles

Executive

Templates

VFX

Code

Code Gallery Designer

v5.20

Maya

Check Camera Blocked

Jorge Hernandez Ibañez 14/10/2025

Tags
cameras animation check

Check Camera Blocked

Jorge Herna…

Action v1

14/10/2025

Maya

Pseudo-Code

Parameters

Talk with TD Support

Import to my Pipeline

Code

import pipelinepro
import maya.cmds as cmds
import os
import re

def get_file_data(filename):
    query = """
    query {
      file(fileName: "{filename}", token:"{token}") {
        task{
          name
          code
          maintask{
            tecnicalName
            name
          }
        }
        shot{
          name
        }
      }
    }
    """
    query = query.replace("{filename}", filename)
    response = pipelinepro.query(query)
    if not response:
        return
    return response.get("file")

def get_pipeline_cameras(task_code):
    """
    Get all cameras that match the pipeline naming structure
    Returns a list of camera transform node full paths
    """
    pipeline_cameras = []
    
    # Get all cameras in the scene
    all_cameras = cmds.ls(type="camera") or []
    
    # Build regex pattern for valid camera structure
    # Pattern: |Cameras|{cameraType}|{task_code}_{cameraType}_grp|{task_code}_{cameraType}
    pattern = rf"^\|Cameras\|(\w+)\|{re.escape(task_code)}_\1_grp\|{re.escape(task_code)}_\1$"
    
    # Check each camera's long name against the pattern
    for camera_shape in all_cameras:
        # Get the transform node (parent) of the camera shape
        camera_transforms = cmds.listRelatives(camera_shape, parent=True, fullPath=True) or []
        
        for camera_transform in camera_transforms:
            # Match the long name against the expected pattern
            if re.match(pattern, camera_transform):
                pipeline_cameras.append(camera_transform)
    
    return pipeline_cameras

def is_camera_blocked(camera_transform):
    """
    Check if a camera transform has all its transform attributes locked
    """
    # Attributes to check for locking
    attributes = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz']
    
    for attr in attributes:
        full_attr = f"{camera_transform}.{attr}"
        if not cmds.getAttr(full_attr, lock=True):
            return False
    
    return True

def block_camera(camera_transform):
    """
    Lock all transform attributes of a camera
    """
    attributes = ['tx', 'ty', 'tz', 'rx', 'ry', 'rz', 'sx', 'sy', 'sz']
    
    for attr in attributes:
        full_attr = f"{camera_transform}.{attr}"
        cmds.setAttr(full_attr, lock=True)

def check_process():
    # Get current file name
    current_file = cmds.file(query=True, sceneName=True)
    if not current_file:
        return False, "No file is currently open"
    
    filename = os.path.basename(current_file)
    
    # Get file data from pipeline
    file_data = get_file_data(filename)
    if not file_data:
        return False, "Could not retrieve file data from pipeline"
    
    task_code = file_data.get("task", {}).get("code")
    if not task_code:
        return False, "Could not retrieve task code from pipeline"
    
    # Check if Cameras group exists
    if not cmds.objExists("Cameras"):
        return False, "Cameras group not found"
    
    # Get all pipeline cameras
    pipeline_cameras = get_pipeline_cameras(task_code)
    
    if not pipeline_cameras:
        return False, "No pipeline cameras found"
    
    # Check if all pipeline cameras are blocked
    unblocked_cameras = []
    for camera in pipeline_cameras:
        if not is_camera_blocked(camera):
            unblocked_cameras.append(camera)
    
    if unblocked_cameras:
        camera_names = [cam.split('|')[-1] for cam in unblocked_cameras]
        return False, f"The following pipeline cameras are not blocked: {', '.join(camera_names)}"
    
    return True, False

def select_process():
    # Get current file name
    current_file = cmds.file(query=True, sceneName=True)
    if not current_file:
        return False, "No file is currently open"
    
    filename = os.path.basename(current_file)
    
    # Get file data from pipeline
    file_data = get_file_data(filename)
    if not file_data:
        return False, "Could not retrieve file data from pipeline"
    
    task_code = file_data.get("task", {}).get("code")
    if not task_code:
        return False, "Could not retrieve task code from pipeline"
    
    # Get all pipeline cameras
    pipeline_cameras = get_pipeline_cameras(task_code)
    
    # Find unblocked cameras
    unblocked_cameras = []
    for camera in pipeline_cameras:
        if not is_camera_blocked(camera):
            unblocked_cameras.append(camera)
    
    if unblocked_cameras:
        # Clear selection and select unblocked cameras
        cmds.select(clear=True)
        cmds.select(unblocked_cameras, add=True)
        return True, False
    else:
        return False, "No unblocked pipeline cameras to select"

def fix_process():
    # Get current file name
    current_file = cmds.file(query=True, sceneName=True)
    if not current_file:
        return False
    
    filename = os.path.basename(current_file)
    
    # Get file data from pipeline
    file_data = get_file_data(filename)
    if not file_data:
        return False
    
    task_code = file_data.get("task", {}).get("code")
    if not task_code:
        return False
    
    try:
        # Get all pipeline cameras
        pipeline_cameras = get_pipeline_cameras(task_code)
        
        if not pipeline_cameras:
            print("No pipeline cameras found to block")
            return False
        
        # Block all unblocked pipeline cameras
        blocked_count = 0
        for camera in pipeline_cameras:
            if not is_camera_blocked(camera):
                block_camera(camera)
                blocked_count += 1
                camera_name = camera.split('|')[-1]
                print(f"Blocked camera: {camera_name}")
        
        if blocked_count > 0:
            print(f"Successfully blocked {blocked_count} camera(s)")
            return True
        else:
            print("All pipeline cameras were already blocked")
            return True
        
    except Exception as e:
        print(f"Error blocking cameras: {str(e)}")
        return False

#---------------------------------------------------------------------------------------------
def check(): # UI Functions, dont change
    check_result, check_error = check_process()
    
    if check_result:
        return True
    else:
        return check_error

def select():
    select_result, select_error = select_process()
    
    if select_result:
        return True
    else:
        return select_error

def fix(): # UI Functions, dont change
    fix_result = fix_process()
    check_result = check()
    return fix_result, check_result

Import Action

1. Copy Key

Copy

2. Go to your Action pannel

Go