#!/usr/bin/env python # -*- coding: utf-8 -*- """ Tool - Joint Utilities Provides utilities for working with joints and skeletons in Maya """ import os import sys import json import maya.cmds as cmds import maya.mel as mel # Import configuration try: import config except ImportError: # Try relative import if direct import fails try: from ... import config except ImportError: # If both fail, try to get from sys.modules import sys if 'config' in sys.modules: config = sys.modules['config'] else: raise ImportError("Could not import config module") class JointUtils: """Utilities for working with joints and skeletons in Maya""" def __init__(self): """Initialize joint utilities""" # MetaHuman joint mapping for different versions self.mh_joint_mapping = { "MH.4": { # Core skeleton joints "root": "root", "spine": "spine_01", "spine1": "spine_02", "spine2": "spine_03", "neck": "neck_01", "head": "head", # Left arm "l_shoulder": "clavicle_l", "l_arm": "upperarm_l", "l_elbow": "lowerarm_l", "l_wrist": "hand_l", # Right arm "r_shoulder": "clavicle_r", "r_arm": "upperarm_r", "r_elbow": "lowerarm_r", "r_wrist": "hand_r", # Left leg "l_hip": "thigh_l", "l_knee": "calf_l", "l_ankle": "foot_l", "l_toe": "ball_l", # Right leg "r_hip": "thigh_r", "r_knee": "calf_r", "r_ankle": "foot_r", "r_toe": "ball_r", # Face joints (core) "jaw": "jaw", "l_eye": "eye_l", "r_eye": "eye_r" }, "MH.3": { # Similar structure with some naming differences "root": "root", "spine": "spine_01", "spine1": "spine_02", "spine2": "spine_03", "neck": "neck_01", "head": "head", # Left arm "l_shoulder": "clavicle_l", "l_arm": "upperarm_l", "l_elbow": "lowerarm_l", "l_wrist": "hand_l", # Right arm "r_shoulder": "clavicle_r", "r_arm": "upperarm_r", "r_elbow": "lowerarm_r", "r_wrist": "hand_r", # Left leg "l_hip": "thigh_l", "l_knee": "calf_l", "l_ankle": "foot_l", "l_toe": "ball_l", # Right leg "r_hip": "thigh_r", "r_knee": "calf_r", "r_ankle": "foot_r", "r_toe": "ball_r", # Face joints (core) "jaw": "jaw", "l_eye": "eye_l", "r_eye": "eye_r" } } # Current calibration data self.current_calibration = { "reference": None, "target": None, "mapping": {}, "status": {} } def create_metahuman_skeleton(self, mesh): """ Create a MetaHuman skeleton for a mesh Args: mesh (str): Name of the mesh Returns: bool: True if successful, False otherwise """ try: # Check if mesh exists if not cmds.objExists(mesh): cmds.warning(f"Mesh does not exist: {mesh}") return False # Get mesh shape shapes = cmds.listRelatives(mesh, shapes=True, type="mesh") if not shapes: cmds.warning(f"Object is not a mesh: {mesh}") return False # Create root joint root_joint = cmds.joint(name=f"{mesh}_root", position=(0, 0, 0)) # Create MetaHuman skeleton structure # This is a simplified version - a real implementation would create # a complete skeleton based on MetaHuman joint structure spine_joint = cmds.joint(name=f"{mesh}_spine", position=(0, 100, 0)) neck_joint = cmds.joint(name=f"{mesh}_neck", position=(0, 120, 0)) head_joint = cmds.joint(name=f"{mesh}_head", position=(0, 140, 0)) # Return to spine to create left arm cmds.select(spine_joint) l_shoulder_joint = cmds.joint(name=f"{mesh}_l_shoulder", position=(20, 110, 0)) l_elbow_joint = cmds.joint(name=f"{mesh}_l_elbow", position=(40, 100, 0)) l_wrist_joint = cmds.joint(name=f"{mesh}_l_wrist", position=(60, 90, 0)) # Return to spine to create right arm cmds.select(spine_joint) r_shoulder_joint = cmds.joint(name=f"{mesh}_r_shoulder", position=(-20, 110, 0)) r_elbow_joint = cmds.joint(name=f"{mesh}_r_elbow", position=(-40, 100, 0)) r_wrist_joint = cmds.joint(name=f"{mesh}_r_wrist", position=(-60, 90, 0)) # Return to root to create left leg cmds.select(root_joint) l_hip_joint = cmds.joint(name=f"{mesh}_l_hip", position=(10, 80, 0)) l_knee_joint = cmds.joint(name=f"{mesh}_l_knee", position=(10, 40, 0)) l_ankle_joint = cmds.joint(name=f"{mesh}_l_ankle", position=(10, 10, 0)) # Return to root to create right leg cmds.select(root_joint) r_hip_joint = cmds.joint(name=f"{mesh}_r_hip", position=(-10, 80, 0)) r_knee_joint = cmds.joint(name=f"{mesh}_r_knee", position=(-10, 40, 0)) r_ankle_joint = cmds.joint(name=f"{mesh}_r_ankle", position=(-10, 10, 0)) # Orient joints cmds.select(root_joint) cmds.joint(edit=True, orientJoint="xyz", secondaryAxisOrient="yup") # Center skeleton to mesh self._center_skeleton_to_mesh(root_joint, mesh) print(f"Successfully created MetaHuman skeleton for {mesh}") return True except Exception as e: cmds.warning(f"Error creating MetaHuman skeleton: {str(e)}") return False def load_metahuman_reference(self): """ Load MetaHuman reference skeleton Returns: bool: True if successful, False otherwise """ try: # Check if reference file exists reference_file = os.path.join(config.METAHUMAN_PATH, "reference", "metahuman_skeleton.mb") if not os.path.exists(reference_file): cmds.warning(f"MetaHuman reference skeleton file does not exist: {reference_file}") return False # Import reference file cmds.file(reference_file, reference=True, namespace="metahuman_reference") print(f"Successfully loaded MetaHuman reference skeleton") return True except Exception as e: cmds.warning(f"Error loading MetaHuman reference skeleton: {str(e)}") return False def load_custom_reference(self, file_path): """ Load custom reference skeleton Args: file_path (str): Path to the reference file Returns: bool: True if successful, False otherwise """ try: # Check if file exists if not os.path.exists(file_path): cmds.warning(f"Reference skeleton file does not exist: {file_path}") return False # Determine file type if file_path.lower().endswith(".json"): # Load from JSON with open(file_path, "r") as f: reference_data = json.load(f) # Create reference skeleton from JSON data self._create_skeleton_from_json(reference_data) else: # Import reference file cmds.file(file_path, reference=True, namespace="custom_reference") print(f"Successfully loaded custom reference skeleton: {file_path}") return True except Exception as e: cmds.warning(f"Error loading custom reference skeleton: {str(e)}") return False def auto_calibrate(self, skeleton): """ Auto-calibrate a skeleton Args: skeleton (str): Name of the skeleton root Returns: bool: True if successful, False otherwise """ try: # Check if skeleton exists if not cmds.objExists(skeleton): cmds.warning(f"骨架不存在: {skeleton}") return False # Get reference skeleton reference_skeleton = None references = cmds.ls("*:*_root", type="joint") if not references: cmds.warning("未找到参考骨架，请先加载参考骨架") return False reference_skeleton = references[0] # Get all joints in the skeleton joints = self._get_all_joints(skeleton) reference_joints = self._get_all_joints(reference_skeleton) # Map joints by name joint_map = {} for joint in joints: joint_name = joint.split("|")[-1].split(":")[-1] # Find matching reference joint for ref_joint in reference_joints: ref_joint_name = ref_joint.split("|")[-1].split(":")[-1] if joint_name == ref_joint_name: joint_map[joint] = ref_joint break # Calibrate joints for joint, ref_joint in joint_map.items(): # Get reference joint position ref_pos = cmds.xform(ref_joint, query=True, worldSpace=True, translation=True) # Set joint position to reference cmds.xform(joint, worldSpace=True, translation=ref_pos) # Get reference joint orientation ref_rot = cmds.xform(ref_joint, query=True, worldSpace=True, rotation=True) # Set joint orientation to reference cmds.xform(joint, worldSpace=True, rotation=ref_rot) print(f"成功自动校准骨架: {skeleton}") return True except Exception as e: cmds.warning(f"自动校准骨架出错: {str(e)}") return False def show_manual_calibration_ui(self, joint): """ Show manual calibration UI for a joint Args: joint (str): Name of the joint Returns: bool: True if successful, False otherwise """ try: # Check if joint exists if not cmds.objExists(joint): cmds.warning(f"关节不存在: {joint}") return False # Create UI if cmds.window("manualCalibrationUI", exists=True): cmds.deleteUI("manualCalibrationUI") window = cmds.window("manualCalibrationUI", title=f"手动校准 - {joint}", width=300) cmds.columnLayout(adjustableColumn=True) # Position controls cmds.frameLayout(label="位置", collapsable=True, collapse=False) cmds.columnLayout(adjustableColumn=True) pos = cmds.xform(joint, query=True, worldSpace=True, translation=True) cmds.floatSliderGrp("posX", label="X", field=True, minValue=-100, maxValue=100, value=pos[0], step=0.1, changeCommand=lambda x: self._update_joint_position(joint, 0, x)) cmds.floatSliderGrp("posY", label="Y", field=True, minValue=-100, maxValue=100, value=pos[1], step=0.1, changeCommand=lambda x: self._update_joint_position(joint, 1, x)) cmds.floatSliderGrp("posZ", label="Z", field=True, minValue=-100, maxValue=100, value=pos[2], step=0.1, changeCommand=lambda x: self._update_joint_position(joint, 2, x)) cmds.setParent("..") cmds.setParent("..") # Rotation controls cmds.frameLayout(label="旋转", collapsable=True, collapse=False) cmds.columnLayout(adjustableColumn=True) rot = cmds.xform(joint, query=True, worldSpace=True, rotation=True) cmds.floatSliderGrp("rotX", label="X", field=True, minValue=-180, maxValue=180, value=rot[0], step=1, changeCommand=lambda x: self._update_joint_rotation(joint, 0, x)) cmds.floatSliderGrp("rotY", label="Y", field=True, minValue=-180, maxValue=180, value=rot[1], step=1, changeCommand=lambda x: self._update_joint_rotation(joint, 1, x)) cmds.floatSliderGrp("rotZ", label="Z", field=True, minValue=-180, maxValue=180, value=rot[2], step=1, changeCommand=lambda x: self._update_joint_rotation(joint, 2, x)) cmds.setParent("..") cmds.setParent("..") # Buttons cmds.rowLayout(numberOfColumns=3, columnWidth3=(100, 100, 100), adjustableColumn=2, columnAlign=(1, "center"), columnAttach=[(1, "both", 0), (2, "both", 0), (3, "both", 0)]) cmds.button(label="重置", command=lambda x: self._reset_joint(joint)) cmds.button(label="应用", command=lambda x: self._apply_joint_calibration(joint)) cmds.button(label="关闭", command=lambda x: cmds.deleteUI("manualCalibrationUI")) cmds.setParent("..") cmds.showWindow(window) return True except Exception as e: cmds.warning(f"显示手动校准界面出错: {str(e)}") return False def reset_calibration(self, skeleton): """ Reset calibration for a skeleton Args: skeleton (str): Name of the skeleton root Returns: bool: True if successful, False otherwise """ try: # Check if skeleton exists if not cmds.objExists(skeleton): cmds.warning(f"骨架不存在: {skeleton}") return False # Get all joints in the skeleton joints = self._get_all_joints(skeleton) # Reset joint positions and orientations for joint in joints: # Reset position cmds.setAttr(f"{joint}.translateX", 0) cmds.setAttr(f"{joint}.translateY", 0) cmds.setAttr(f"{joint}.translateZ", 0) # Reset rotation cmds.setAttr(f"{joint}.rotateX", 0) cmds.setAttr(f"{joint}.rotateY", 0) cmds.setAttr(f"{joint}.rotateZ", 0) # Reset scale cmds.setAttr(f"{joint}.scaleX", 1) cmds.setAttr(f"{joint}.scaleY", 1) cmds.setAttr(f"{joint}.scaleZ", 1) print(f"成功重置骨架校准: {skeleton}") return True except Exception as e: cmds.warning(f"重置骨架校准出错: {str(e)}") return False def apply_calibration(self, skeleton): """ Apply calibration to a skeleton Args: skeleton (str): Name of the skeleton root Returns: bool: True if successful, False otherwise """ try: # Check if skeleton exists if not cmds.objExists(skeleton): cmds.warning(f"骨架不存在: {skeleton}") return False # Get all joints in the skeleton joints = self._get_all_joints(skeleton) # Apply calibration for joint in joints: # Store current position and orientation pos = cmds.xform(joint, query=True, worldSpace=True, translation=True) rot = cmds.xform(joint, query=True, worldSpace=True, rotation=True) # Store calibration data calibration_data = { "position": pos, "rotation": rot } # Add calibration data as attributes if not cmds.attributeQuery("calibrationData", node=joint, exists=True): cmds.addAttr(joint, longName="calibrationData", dataType="string") cmds.setAttr(f"{joint}.calibrationData", json.dumps(calibration_data), type="string") print(f"Successfully applied skeleton calibration: {skeleton}") return True except Exception as e: cmds.warning(f"Error applying skeleton calibration: {str(e)}") return False def get_joints_info(self, skeleton): """ Get information about joints in a skeleton Args: skeleton (str): Name of the skeleton root Returns: dict: Dictionary of joint information """ try: # Check if skeleton exists if not cmds.objExists(skeleton): cmds.warning(f"Skeleton does not exist: {skeleton}") return {} # Get all joints in the skeleton joints = self._get_all_joints(skeleton) # Get joint information joints_info = {} for joint in joints: # Get joint name joint_name = joint.split("|")[-1] # Get joint position pos = cmds.xform(joint, query=True, worldSpace=True, translation=True) # Get joint rotation rot = cmds.xform(joint, query=True, worldSpace=True, rotation=True) # Get calibration status status = "未校准" if cmds.attributeQuery("calibrationData", node=joint, exists=True): status = "已校准" # Add joint information joints_info[joint_name] = { "position": pos, "rotation": rot, "status": status } return joints_info except Exception as e: cmds.warning(f"Error getting joint information: {str(e)}") return {} def update_visualization(self, show_reference=True, show_current=True, show_differences=True): """ Update visualization of skeletons Args: show_reference (bool, optional): Show reference skeleton show_current (bool, optional): Show current skeleton show_differences (bool, optional): Show differences between skeletons Returns: bool: True if successful, False otherwise """ try: # Get reference skeleton reference_skeleton = None references = cmds.ls("*:*_root", type="joint") if references: reference_skeleton = references[0] # Get current skeleton current_skeleton = None skeletons = cmds.ls("*_root", type="joint") if skeletons: # Filter out reference skeletons for skeleton in skeletons: if ":" not in skeleton: current_skeleton = skeleton break # Show/hide reference skeleton if reference_skeleton: cmds.setAttr(f"{reference_skeleton}.visibility", show_reference) # Show/hide current skeleton if current_skeleton: cmds.setAttr(f"{current_skeleton}.visibility", show_current) # Show/hide differences if show_differences and reference_skeleton and current_skeleton: self._visualize_differences(reference_skeleton, current_skeleton) else: # Remove difference visualization if cmds.objExists("difference_visualization"): cmds.delete("difference_visualization") return True except Exception as e: cmds.warning(f"Error updating visualization: {str(e)}") return False def _center_skeleton_to_mesh(self, root_joint, mesh): """ Center a skeleton to a mesh Args: root_joint (str): Name of the root joint mesh (str): Name of the mesh Returns: bool: True if successful, False otherwise """ try: # Get mesh bounding box bbox = cmds.exactWorldBoundingBox(mesh) # Calculate center center_x = (bbox[0] + bbox[3]) / 2 center_y = bbox[1] # Bottom of the mesh center_z = (bbox[2] + bbox[5]) / 2 # Move root joint to center cmds.xform(root_joint, worldSpace=True, translation=(center_x, center_y, center_z)) return True except Exception as e: cmds.warning(f"Error centering skeleton to mesh: {str(e)}") return False def _create_skeleton_from_json(self, data): """ Create a skeleton from JSON data Args: data (dict): Skeleton data Returns: bool: True if successful, False otherwise """ try: # Create root joint root_joint = cmds.joint(name=data["root"]["name"], position=data["root"]["position"]) # Create child joints self._create_child_joints(root_joint, data["root"]["children"]) # Orient joints cmds.select(root_joint) cmds.joint(edit=True, orientJoint="xyz", secondaryAxisOrient="yup") return True except Exception as e: cmds.warning(f"Error creating skeleton from JSON: {str(e)}") return False def _create_child_joints(self, parent_joint, children): """ Create child joints Args: parent_joint (str): Name of the parent joint children (list): List of child joint data Returns: bool: True if successful, False otherwise """ try: for child in children: # Select parent cmds.select(parent_joint) # Create child joint child_joint = cmds.joint(name=child["name"], position=child["position"]) # Create grandchildren if "children" in child: self._create_child_joints(child_joint, child["children"]) return True except Exception as e: cmds.warning(f"Error creating child joints: {str(e)}") return False def _get_all_joints(self, root_joint): """ Get all joints in a hierarchy Args: root_joint (str): Name of the root joint Returns: list: List of joint names """ try: # Check if root joint exists if not cmds.objExists(root_joint): return [] # Get all joints in the hierarchy joints = cmds.listRelatives(root_joint, allDescendents=True, type="joint") or [] joints.append(root_joint) return joints except Exception as e: cmds.warning(f"Error getting joints: {str(e)}") return [] def _update_joint_position(self, joint, axis, value): """ Update joint position Args: joint (str): Name of the joint axis (int): Axis index (0=X, 1=Y, 2=Z) value (float): New value Returns: bool: True if successful, False otherwise """ try: # Get current position pos = cmds.xform(joint, query=True, worldSpace=True, translation=True) # Update position pos[axis] = value # Set new position cmds.xform(joint, worldSpace=True, translation=pos) return True except Exception as e: cmds.warning(f"Error updating joint position: {str(e)}") return False def _update_joint_rotation(self, joint, axis, value): """ Update joint rotation Args: joint (str): Name of the joint axis (int): Axis index (0=X, 1=Y, 2=Z) value (float): New value Returns: bool: True if successful, False otherwise """ try: # Get current rotation rot = cmds.xform(joint, query=True, worldSpace=True, rotation=True) # Update rotation rot[axis] = value # Set new rotation cmds.xform(joint, worldSpace=True, rotation=rot) return True except Exception as e: cmds.warning(f"Error updating joint rotation: {str(e)}") return False def _reset_joint(self, joint): """ Reset joint position and rotation Args: joint (str): Name of the joint Returns: bool: True if successful, False otherwise """ try: # Reset position cmds.setAttr(f"{joint}.translateX", 0) cmds.setAttr(f"{joint}.translateY", 0) cmds.setAttr(f"{joint}.translateZ", 0) # Reset rotation cmds.setAttr(f"{joint}.rotateX", 0) cmds.setAttr(f"{joint}.rotateY", 0) cmds.setAttr(f"{joint}.rotateZ", 0) # Update UI if cmds.window("manualCalibrationUI", exists=True): pos = cmds.xform(joint, query=True, worldSpace=True, translation=True) rot = cmds.xform(joint, query=True, worldSpace=True, rotation=True) cmds.floatSliderGrp("posX", edit=True, value=pos[0]) cmds.floatSliderGrp("posY", edit=True, value=pos[1]) cmds.floatSliderGrp("posZ", edit=True, value=pos[2]) cmds.floatSliderGrp("rotX", edit=True, value=rot[0]) cmds.floatSliderGrp("rotY", edit=True, value=rot[1]) cmds.floatSliderGrp("rotZ", edit=True, value=rot[2]) return True except Exception as e: cmds.warning(f"Error resetting joint: {str(e)}") return False def _apply_joint_calibration(self, joint): """ Apply joint calibration Args: joint (str): Name of the joint Returns: bool: True if successful, False otherwise """ try: # Get current position and rotation pos = cmds.xform(joint, query=True, worldSpace=True, translation=True) rot = cmds.xform(joint, query=True, worldSpace=True, rotation=True) # Store calibration data calibration_data = { "position": pos, "rotation": rot } # Add calibration data as attributes if not cmds.attributeQuery("calibrationData", node=joint, exists=True): cmds.addAttr(joint, longName="calibrationData", dataType="string") cmds.setAttr(f"{joint}.calibrationData", json.dumps(calibration_data), type="string") print(f"Successfully applied joint calibration: {joint}") return True except Exception as e: cmds.warning(f"Error applying joint calibration: {str(e)}") return False def _visualize_differences(self, reference_skeleton, current_skeleton): """ Visualize differences between skeletons Args: reference_skeleton (str): Name of the reference skeleton root current_skeleton (str): Name of the current skeleton root Returns: bool: True if successful, False otherwise """ try: # Remove existing visualization if cmds.objExists("difference_visualization"): cmds.delete("difference_visualization") # Create visualization group vis_group = cmds.group(empty=True, name="difference_visualization") # Get all joints in both skeletons ref_joints = self._get_all_joints(reference_skeleton) cur_joints = self._get_all_joints(current_skeleton) # Map joints by name joint_map = {} # Try to use existing mapping if available if self.current_calibration["mapping"] and self.current_calibration["reference"] == reference_skeleton and self.current_calibration["target"] == current_skeleton: # Use existing mapping for cur_joint in cur_joints: cur_joint_name = cur_joint.split("|")[-1].split(":")[-1] if cur_joint_name in self.current_calibration["mapping"]: ref_joint_name = self.current_calibration["mapping"][cur_joint_name] # Find the full path to the reference joint for ref_joint in ref_joints: if ref_joint.endswith(ref_joint_name): joint_map[cur_joint] = ref_joint break else: # Create mapping by name for cur_joint in cur_joints: cur_joint_name = cur_joint.split("|")[-1].split(":")[-1] # Find matching reference joint for ref_joint in ref_joints: ref_joint_name = ref_joint.split("|")[-1].split(":")[-1] if cur_joint_name == ref_joint_name: joint_map[cur_joint] = ref_joint break # Create lines between corresponding joints for cur_joint, ref_joint in joint_map.items(): # Get positions cur_pos = cmds.xform(cur_joint, query=True, worldSpace=True, translation=True) ref_pos = cmds.xform(ref_joint, query=True, worldSpace=True, translation=True) # Calculate distance distance = ((cur_pos[0] - ref_pos[0]) ** 2 + (cur_pos[1] - ref_pos[1]) ** 2 + (cur_pos[2] - ref_pos[2]) ** 2) ** 0.5 # Skip if too close if distance < 0.001: continue # Create curve curve = cmds.curve(degree=1, point=[cur_pos, ref_pos]) # Set color based on distance cmds.setAttr(f"{curve}.overrideEnabled", 1) if distance < 1.0: cmds.setAttr(f"{curve}.overrideColor", 14) # Green elif distance < 5.0: cmds.setAttr(f"{curve}.overrideColor", 17) # Yellow else: cmds.setAttr(f"{curve}.overrideColor", 13) # Red # Add to group cmds.parent(curve, vis_group) # Add distance text text_pos = [(cur_pos[0] + ref_pos[0]) / 2, (cur_pos[1] + ref_pos[1]) / 2, (cur_pos[2] + ref_pos[2]) / 2] text = cmds.textCurves(text=f"{distance:.2f}", font="smallPlainText")[0] cmds.scale(0.2, 0.2, 0.2, text) cmds.move(text_pos[0], text_pos[1], text_pos[2], text) cmds.parent(text, vis_group) return True except Exception as e: cmds.warning(f"Error visualizing differences: {str(e)}") return False def detect_skeleton_type(self, skeleton_root): """ Detect the type of skeleton (MetaHuman, Custom, etc.) Args: skeleton_root (str): Name of the skeleton root Returns: str: Skeleton type ("MH.4", "MH.3", "Custom", etc.) """ try: # Get all joints joints = self._get_all_joints(skeleton_root) if not joints: return "Unknown" # Count total joints joint_count = len(joints) # Check for MetaHuman specific joints mh4_specific = ["spine_04", "thumb_03_l", "thumb_03_r"] mh3_specific = ["spine_03", "thumb_02_l", "thumb_02_r"] mh4_count = 0 mh3_count = 0 for joint in joints: joint_name = joint.split("|")[-1].split(":")[-1] for specific in mh4_specific: if specific in joint_name: mh4_count += 1 for specific in mh3_specific: if specific in joint_name: mh3_count += 1 # MetaHuman 4 typically has 411 joints if joint_count >= 400 and joint_count <= 420 and mh4_count >= 2: return "MH.4" # MetaHuman 3 typically has 245 joints elif joint_count >= 240 and joint_count <= 260 and mh3_count >= 2: return "MH.3" # Generic MetaHuman elif "spine_01" in str(joints) and "clavicle_l" in str(joints) and "clavicle_r" in str(joints): return "MetaHuman" else: return "Custom" except Exception as e: cmds.warning(f"Error detecting skeleton type: {str(e)}") return "Unknown" def create_joint_mapping(self, source_skeleton, target_skeleton, mapping_type="auto"): """ Create a mapping between joints in two skeletons Args: source_skeleton (str): Name of the source skeleton root target_skeleton (str): Name of the target skeleton root mapping_type (str): Type of mapping ("auto", "name", "position", "hierarchy") Returns: dict: Mapping from source joint names to target joint names """ try: # Get all joints source_joints = self._get_all_joints(source_skeleton) target_joints = self._get_all_joints(target_skeleton) if not source_joints or not target_joints: return {} # Detect skeleton types source_type = self.detect_skeleton_type(source_skeleton) target_type = self.detect_skeleton_type(target_skeleton) # Initialize mapping mapping = {} # If both are MetaHuman, use predefined mapping if source_type in ["MH.4", "MH.3", "MetaHuman"] and target_type in ["MH.4", "MH.3", "MetaHuman"]: # Get source and target mappings source_map = self.mh_joint_mapping.get(source_type, self.mh_joint_mapping["MH.4"]) target_map = self.mh_joint_mapping.get(target_type, self.mh_joint_mapping["MH.4"]) # Create mapping from source to target for generic_name, source_name in source_map.items(): if generic_name in target_map: target_name = target_map[generic_name] # Find full joint names source_full = None target_full = None for joint in source_joints: if joint.endswith(source_name): source_full = joint.split("|")[-1].split(":")[-1] break for joint in target_joints: if joint.endswith(target_name): target_full = joint.split("|")[-1].split(":")[-1] break if source_full and target_full: mapping[source_full] = target_full else: # Use the specified mapping type if mapping_type == "name" or mapping_type == "auto": # Map by name for source_joint in source_joints: source_name = source_joint.split("|")[-1].split(":")[-1] for target_joint in target_joints: target_name = target_joint.split("|")[-1].split(":")[-1] if source_name == target_name: mapping[source_name] = target_name break if mapping_type == "position" or (mapping_type == "auto" and len(mapping) < len(source_joints) * 0.5): # Map by position (for joints not mapped by name) for source_joint in source_joints: source_name = source_joint.split("|")[-1].split(":")[-1] if source_name in mapping: continue # Get source position source_pos = cmds.xform(source_joint, query=True, worldSpace=True, translation=True) # Find closest target joint closest_joint = None closest_distance = float("inf") for target_joint in target_joints: target_name = target_joint.split("|")[-1].split(":")[-1] # Skip if already mapped if target_name in mapping.values(): continue # Get target position target_pos = cmds.xform(target_joint, query=True, worldSpace=True, translation=True) # Calculate distance distance = ((source_pos[0] - target_pos[0]) ** 2 + (source_pos[1] - target_pos[1]) ** 2 + (source_pos[2] - target_pos[2]) ** 2) ** 0.5 if distance < closest_distance: closest_distance = distance closest_joint = target_name if closest_joint and closest_distance < 10.0: # Threshold for position mapping mapping[source_name] = closest_joint if mapping_type == "hierarchy" or (mapping_type == "auto" and len(mapping) < len(source_joints) * 0.7): # Map by hierarchy (for remaining joints) # This is a simplified implementation - a real one would be more complex source_hierarchy = self._get_joint_hierarchy(source_skeleton) target_hierarchy = self._get_joint_hierarchy(target_skeleton) # Map root joints if source_hierarchy and target_hierarchy: source_root = list(source_hierarchy.keys())[0] target_root = list(target_hierarchy.keys())[0] if source_root not in mapping: mapping[source_root] = target_root # Map children based on relative positions in hierarchy self._map_children_by_hierarchy(source_hierarchy, target_hierarchy, source_root, target_root, mapping) # Store the mapping self.current_calibration["reference"] = source_skeleton self.current_calibration["target"] = target_skeleton self.current_calibration["mapping"] = mapping return mapping except Exception as e: cmds.warning(f"Error creating joint mapping: {str(e)}") return {} def _get_joint_hierarchy(self, root_joint): """ Get the hierarchy of joints Args: root_joint (str): Name of the root joint Returns: dict: Hierarchy of joints """ try: # Initialize hierarchy hierarchy = {} # Get the root joint name root_name = root_joint.split("|")[-1].split(":")[-1] # Get children children = cmds.listRelatives(root_joint, children=True, type="joint") or [] # Add to hierarchy hierarchy[root_name] = [] # Process children for child in children: child_hierarchy = self._get_joint_hierarchy(child) hierarchy[root_name].append(child_hierarchy) return hierarchy except Exception as e: cmds.warning(f"Error getting joint hierarchy: {str(e)}") return {} def _map_children_by_hierarchy(self, source_hierarchy, target_hierarchy, source_parent, target_parent, mapping): """ Map children by hierarchy Args: source_hierarchy (dict): Source hierarchy target_hierarchy (dict): Target hierarchy source_parent (str): Source parent joint target_parent (str): Target parent joint mapping (dict): Current mapping to update Returns: None """ try: # Get source and target children source_children = source_hierarchy.get(source_parent, []) target_children = target_hierarchy.get(target_parent, []) if not source_children or not target_children: return # If same number of children, map directly if len(source_children) == len(target_children): for i in range(len(source_children)): source_child = list(source_children[i].keys())[0] target_child = list(target_children[i].keys())[0] if source_child not in mapping: mapping[source_child] = target_child # Recursively map grandchildren self._map_children_by_hierarchy(source_hierarchy, target_hierarchy, source_child, target_child, mapping) else: # Different number of children, try to map by name or position for source_child_dict in source_children: source_child = list(source_child_dict.keys())[0] if source_child in mapping: continue # Try to find by name found = False for target_child_dict in target_children: target_child = list(target_child_dict.keys())[0] if target_child in mapping.values(): continue if source_child == target_child or source_child.lower() == target_child.lower(): mapping[source_child] = target_child found = True # Recursively map grandchildren self._map_children_by_hierarchy(source_hierarchy, target_hierarchy, source_child, target_child, mapping) break # If not found by name, leave unmapped for now # A more advanced implementation would try position-based mapping here except Exception as e: cmds.warning(f"Error mapping children by hierarchy: {str(e)}") return