""" ProportionChangerParams node - Direct POSE_KEYPOINT editing node Ported from ComfyUI-ultimate-openpose-editor-toyxyz Adjusts pose_keypoint data with key parameters, performing only keypoint transformation without image generation """ import json import copy import math class ProportionChangerParams: """ Parameter adjustment node for direct POSE_KEYPOINT editing Performs only keypoint transformation without image rendering """ @classmethod def INPUT_TYPES(cls): return { "optional": { "pose_keypoint": ("POSE_KEYPOINT", {"default": None}), # === BODY KEYPOINTS (top to bottom order) === "head_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 5.0, "step": 0.01}), "neck_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), "shoulder_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), "arm_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), "upper_arm_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), "lower_arm_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), "torso_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), "pelvis_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), "leg_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), "thigh_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), "lower_leg_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), "feet_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), # === FACE KEYPOINTS (face top to bottom order) === "face_shape_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 5.0, "step": 0.01}), "eyebrow_height": ("FLOAT", {"default": 0.0, "min": -100.0, "max": 100.0, "step": 0.1}), "left_eyebrow_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 5.0, "step": 0.01}), "right_eyebrow_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 5.0, "step": 0.01}), "eye_distance_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 5.0, "step": 0.01}), "eye_height": ("FLOAT", {"default": 0.0, "min": -100.0, "max": 100.0, "step": 0.1}), "left_eye_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 5.0, "step": 0.01}), "right_eye_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 5.0, "step": 0.01}), "nose_scale_face": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 5.0, "step": 0.01}), "mouth_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 5.0, "step": 0.01}), # === HAND KEYPOINTS === "hands_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), # === GLOBAL TRANSFORM === "overall_scale": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01}), "rotate_angle": ("FLOAT", {"default": 0.0, "min": -360.0, "max": 360.0, "step": 0.1}), "translate_x": ("FLOAT", {"default": 0.0, "min": -10000.0, "max": 10000.0, "step": 0.1}), "translate_y": ("FLOAT", {"default": 0.0, "min": -10000.0, "max": 10000.0, "step": 0.1}), } } RETURN_TYPES = ("POSE_KEYPOINT",) RETURN_NAMES = ("changed_pose_keypoint",) FUNCTION = "adjust_pose_keypoint" CATEGORY = "ProportionChanger" @classmethod def IS_CHANGED(cls, **kwargs): """ パラメータが変更された場合は必ず再実行されるようにする ComfyUIのキャッシュ回避のため """ # Hash parameter values to detect changes import hashlib param_str = str(sorted(kwargs.items())) return hashlib.md5(param_str.encode()).hexdigest() def adjust_pose_keypoint(self, pose_keypoint=None, pelvis_scale=1.0, torso_scale=1.0, neck_scale=1.0, head_scale=1.0, eye_distance_scale=1.0, eye_height=0.0, eyebrow_height=0.0, left_eye_scale=1.0, right_eye_scale=1.0, left_eyebrow_scale=1.0, right_eyebrow_scale=1.0, mouth_scale=1.0, nose_scale_face=1.0, face_shape_scale=1.0, shoulder_scale=1.0, arm_scale=1.0, upper_arm_scale=1.0, lower_arm_scale=1.0, leg_scale=1.0, thigh_scale=1.0, lower_leg_scale=1.0, feet_scale=1.0, hands_scale=1.0, overall_scale=1.0, rotate_angle=0.0, translate_x=0.0, translate_y=0.0): """ pose_keypointデータを各種パラメータで調整 Args: pose_keypoint: 入力POSE_KEYPOINTデータ **params: 調整パラメータ Returns: adjusted_pose_keypoint: 調整後のPOSE_KEYPOINTデータ """ # Convert parameters to dictionary format params = { "pelvis_scale": pelvis_scale, "torso_scale": torso_scale, "neck_scale": neck_scale, "head_scale": head_scale, "eye_distance_scale": eye_distance_scale, "eye_height": eye_height, "eyebrow_height": eyebrow_height, "left_eye_scale": left_eye_scale, "right_eye_scale": right_eye_scale, "left_eyebrow_scale": left_eyebrow_scale, "right_eyebrow_scale": right_eyebrow_scale, "mouth_scale": mouth_scale, "nose_scale_face": nose_scale_face, "face_shape_scale": face_shape_scale, "shoulder_scale": shoulder_scale, "arm_scale": arm_scale, "upper_arm_scale": upper_arm_scale, "lower_arm_scale": lower_arm_scale, "leg_scale": leg_scale, "thigh_scale": thigh_scale, "lower_leg_scale": lower_leg_scale, "feet_scale": feet_scale, "hands_scale": hands_scale, "overall_scale": overall_scale, "rotate_angle": rotate_angle, "translate_x": translate_x, "translate_y": translate_y } if pose_keypoint: # Check input data details if isinstance(pose_keypoint, dict): frame_data = pose_keypoint elif isinstance(pose_keypoint, list) and len(pose_keypoint) > 0: frame_data = pose_keypoint[0] else: frame_data = None if frame_data and "people" in frame_data and len(frame_data["people"]) > 0: person = frame_data["people"][0] if "pose_keypoints_2d" in person and len(person["pose_keypoints_2d"]) >= 18: # 肩幅をチェック（Right Shoulder: index 2, Left Shoulder: index 5） kps = person["pose_keypoints_2d"] if len(kps) >= 18: r_shoulder_x, r_shoulder_y = kps[6], kps[7] # index 2 * 3 l_shoulder_x, l_shoulder_y = kps[15], kps[16] # index 5 * 3 shoulder_width = ((r_shoulder_x - l_shoulder_x)**2 + (r_shoulder_y - l_shoulder_y)**2)**0.5 if not pose_keypoint: return (pose_keypoint,) # Do nothing if all parameters are default values default_values = { "pelvis_scale": 1.0, "torso_scale": 1.0, "neck_scale": 1.0, "head_scale": 1.0, "eye_distance_scale": 1.0, "eye_height": 0.0, "eyebrow_height": 0.0, "left_eye_scale": 1.0, "right_eye_scale": 1.0, "left_eyebrow_scale": 1.0, "right_eyebrow_scale": 1.0, "mouth_scale": 1.0, "nose_scale_face": 1.0, "face_shape_scale": 1.0, "shoulder_scale": 1.0, "arm_scale": 1.0, "upper_arm_scale": 1.0, "lower_arm_scale": 1.0, "leg_scale": 1.0, "thigh_scale": 1.0, "lower_leg_scale": 1.0, "feet_scale": 1.0, "hands_scale": 1.0, "overall_scale": 1.0, "rotate_angle": 0.0, "translate_x": 0.0, "translate_y": 0.0 } # Check if all values are default all_default = True for key, default_val in default_values.items(): if abs(params.get(key, default_val) - default_val) > 0.001: # Allow small numerical errors all_default = False break if all_default: # Execute processing even with default values (process from original data, not cached modified data) pass # POSE_KEYPOINTの形式を正規化 (dict形式の場合はリストに変換) # Important: Always create deep copy to never modify the original object if isinstance(pose_keypoint, dict): adjusted_pose = [copy.deepcopy(pose_keypoint)] elif isinstance(pose_keypoint, list): adjusted_pose = copy.deepcopy(pose_keypoint) else: # Always return a copy even for unknown types return (copy.deepcopy(pose_keypoint),) # Process each frame data for frame_data in adjusted_pose: if not isinstance(frame_data, dict) or "people" not in frame_data: continue canvas_width = frame_data.get("canvas_width", 512) canvas_height = frame_data.get("canvas_height", 768) # Adjust pose data for each person for person in frame_data["people"]: self._adjust_person_pose(person, canvas_width, canvas_height, **params) # If input was dict format, return as single dict # Important: Always return as new object to break references to original data if isinstance(pose_keypoint, dict): return (adjusted_pose[0],) else: return (adjusted_pose,) def _adjust_person_pose(self, person, canvas_width, canvas_height, **params): """ 単一人物のポーズデータを調整 """ # Get basic parameters (set default values too) overall_scale = params.get("overall_scale", 1.0) rotate_angle = params.get("rotate_angle", 0.0) translate_x = params.get("translate_x", 0.0) translate_y = params.get("translate_y", 0.0) # 手首の移動量を記録するため、Body keypoints調整前の位置を保存 original_wrist_positions = {} if "pose_keypoints_2d" in person and person["pose_keypoints_2d"]: kps = person["pose_keypoints_2d"] # 手首の位置を記録: Left Wrist (index 7) and Right Wrist (index 4) if len(kps) >= 24: # 8 * 3 = 24 (index 7まで確保) original_wrist_positions["left"] = [kps[21], kps[22]] # index 7 * 3 if len(kps) >= 15: # 5 * 3 = 15 (index 4まで確保) original_wrist_positions["right"] = [kps[12], kps[13]] # index 4 * 3 # Body keypoints調整 if "pose_keypoints_2d" in person and person["pose_keypoints_2d"]: person["pose_keypoints_2d"] = self._adjust_body_keypoints( person["pose_keypoints_2d"], canvas_width, canvas_height, **params ) # 手首の移動量を計算 wrist_movements = {} if "pose_keypoints_2d" in person and person["pose_keypoints_2d"]: kps = person["pose_keypoints_2d"] # 調整後の手首位置と比較 if "left" in original_wrist_positions and len(kps) >= 24: new_left_wrist = [kps[21], kps[22]] wrist_movements["left"] = [ new_left_wrist[0] - original_wrist_positions["left"][0], new_left_wrist[1] - original_wrist_positions["left"][1] ] if "right" in original_wrist_positions and len(kps) >= 15: new_right_wrist = [kps[12], kps[13]] wrist_movements["right"] = [ new_right_wrist[0] - original_wrist_positions["right"][0], new_right_wrist[1] - original_wrist_positions["right"][1] ] # Face keypoints調整 if "face_keypoints_2d" in person and person["face_keypoints_2d"]: person["face_keypoints_2d"] = self._adjust_face_keypoints( person["face_keypoints_2d"], canvas_width, canvas_height, **params ) # Hand keypoints調整（手首の移動量も考慮） if "hand_left_keypoints_2d" in person and person["hand_left_keypoints_2d"]: person["hand_left_keypoints_2d"] = self._adjust_hand_keypoints( person["hand_left_keypoints_2d"], canvas_width, canvas_height, wrist_movement=wrist_movements.get("left", [0.0, 0.0]), **params ) if "hand_right_keypoints_2d" in person and person["hand_right_keypoints_2d"]: person["hand_right_keypoints_2d"] = self._adjust_hand_keypoints( person["hand_right_keypoints_2d"], canvas_width, canvas_height, wrist_movement=wrist_movements.get("right", [0.0, 0.0]), **params ) # 全体変換を最後に適用 self._apply_global_transform( person, canvas_width, canvas_height, overall_scale, rotate_angle, translate_x, translate_y ) def _adjust_body_keypoints(self, keypoints, canvas_width, canvas_height, **params): """ Body keypointsの調整処理 toyxyzの実装を参考にした基本的な部位別スケーリング 全ての変換を元のキーポイントを基準に独立して計算 """ if not keypoints or len(keypoints) < 54: # 18 keypoints * 3 = 54 return keypoints # 元のキーポイントをコピー（参照用） original = keypoints.copy() adjusted = keypoints.copy() # Pose keypoint definitions (corrected based on actual data structure) KP = { "Nose": 0, "Neck": 1, "RShoulder": 2, "RElbow": 3, "RWrist": 4, "LShoulder": 5, "LElbow": 6, "LWrist": 7, "LHip": 8, "LKnee": 9, "LAnkle": 10, "RHip": 11, "RKnee": 12, "RAnkle": 13, "REye": 14, "LEye": 15, "REar": 16, "LEar": 17 } def get_point(kps, index): if index * 3 + 2 >= len(kps) or kps[index * 3 + 2] == 0: return None return [kps[index * 3], kps[index * 3 + 1]] def set_point(kps, index, point): if index * 3 + 1 < len(kps) and point is not None: kps[index * 3] = point[0] kps[index * 3 + 1] = point[1] # Get scaling parameters pelvis_scale = params.get("pelvis_scale", 1.0) torso_scale = params.get("torso_scale", 1.0) neck_scale = params.get("neck_scale", 1.0) head_scale = params.get("head_scale", 1.0) shoulder_scale = params.get("shoulder_scale", 1.0) arm_scale = params.get("arm_scale", 1.0) upper_arm_scale = params.get("upper_arm_scale", 1.0) lower_arm_scale = params.get("lower_arm_scale", 1.0) leg_scale = params.get("leg_scale", 1.0) thigh_scale = params.get("thigh_scale", 1.0) lower_leg_scale = params.get("lower_leg_scale", 1.0) feet_scale = params.get("feet_scale", 1.0) # Get original reference points (always from original keypoints) orig_r_hip = get_point(original, KP["RHip"]) orig_l_hip = get_point(original, KP["LHip"]) orig_neck = get_point(original, KP["Neck"]) orig_nose = get_point(original, KP["Nose"]) if not all([orig_r_hip, orig_l_hip, orig_neck, orig_nose]): return adjusted # Return unchanged if essential keypoints are missing # 階層構造で変換を適用：hip_center -> neck -> shoulders -> arms, legs # 全て元の座標を基準に計算し、依存関係を考慮 # 1. 骨盤の調整（元の座標基準） orig_hip_center = [(orig_r_hip[0] + orig_l_hip[0]) / 2, (orig_r_hip[1] + orig_l_hip[1]) / 2] if pelvis_scale != 1.0: new_r_hip = [ orig_hip_center[0] + (orig_r_hip[0] - orig_hip_center[0]) * pelvis_scale, orig_hip_center[1] + (orig_r_hip[1] - orig_hip_center[1]) * pelvis_scale ] new_l_hip = [ orig_hip_center[0] + (orig_l_hip[0] - orig_hip_center[0]) * pelvis_scale, orig_hip_center[1] + (orig_l_hip[1] - orig_hip_center[1]) * pelvis_scale ] set_point(adjusted, KP["RHip"], new_r_hip) set_point(adjusted, KP["LHip"], new_l_hip) # 新しいhip_centerを計算 current_hip_center = [(new_r_hip[0] + new_l_hip[0]) / 2, (new_r_hip[1] + new_l_hip[1]) / 2] else: current_hip_center = orig_hip_center # 2. Torso adjustment (from original neck, based on hip_center after pelvis adjustment) if torso_scale != 1.0: new_neck = [ current_hip_center[0] + (orig_neck[0] - orig_hip_center[0]) * torso_scale, current_hip_center[1] + (orig_neck[1] - orig_hip_center[1]) * torso_scale ] set_point(adjusted, KP["Neck"], new_neck) current_neck = new_neck else: # pelvis調整による影響のみ適用 neck_offset = [current_hip_center[0] - orig_hip_center[0], current_hip_center[1] - orig_hip_center[1]] current_neck = [orig_neck[0] + neck_offset[0], orig_neck[1] + neck_offset[1]] set_point(adjusted, KP["Neck"], current_neck) # 3. Shoulder adjustment (from original shoulder, based on neck after torso adjustment) orig_r_shoulder = get_point(original, KP["RShoulder"]) orig_l_shoulder = get_point(original, KP["LShoulder"]) if orig_r_shoulder and orig_l_shoulder and shoulder_scale != 1.0: new_r_shoulder = [ current_neck[0] + (orig_r_shoulder[0] - orig_neck[0]) * shoulder_scale, current_neck[1] + (orig_r_shoulder[1] - orig_neck[1]) * shoulder_scale ] new_l_shoulder = [ current_neck[0] + (orig_l_shoulder[0] - orig_neck[0]) * shoulder_scale, current_neck[1] + (orig_l_shoulder[1] - orig_neck[1]) * shoulder_scale ] set_point(adjusted, KP["RShoulder"], new_r_shoulder) set_point(adjusted, KP["LShoulder"], new_l_shoulder) current_r_shoulder, current_l_shoulder = new_r_shoulder, new_l_shoulder else: # torso/pelvisによる影響のみ適用 neck_movement = [current_neck[0] - orig_neck[0], current_neck[1] - orig_neck[1]] current_r_shoulder = [orig_r_shoulder[0] + neck_movement[0], orig_r_shoulder[1] + neck_movement[1]] if orig_r_shoulder else None current_l_shoulder = [orig_l_shoulder[0] + neck_movement[0], orig_l_shoulder[1] + neck_movement[1]] if orig_l_shoulder else None if current_r_shoulder: set_point(adjusted, KP["RShoulder"], current_r_shoulder) if current_l_shoulder: set_point(adjusted, KP["LShoulder"], current_l_shoulder) # 4. Neck/head adjustment (from original nose/head parts, based on neck after torso adjustment) if neck_scale != 1.0 or head_scale != 1.0: # neck_scaleでnoseの位置を調整 if neck_scale != 1.0: new_nose = [ current_neck[0] + (orig_nose[0] - orig_neck[0]) * neck_scale, current_neck[1] + (orig_nose[1] - orig_neck[1]) * neck_scale ] else: # neck移動の影響のみ適用 neck_movement = [current_neck[0] - orig_neck[0], current_neck[1] - orig_neck[1]] new_nose = [orig_nose[0] + neck_movement[0], orig_nose[1] + neck_movement[1]] set_point(adjusted, KP["Nose"], new_nose) # 頭部の他のパーツも調整 for head_kp in ["REye", "LEye", "REar", "LEar"]: if head_kp in KP: orig_head_point = get_point(original, KP[head_kp]) if orig_head_point: # neck_scaleとhead_scaleを組み合わせて適用 # まずneck_scaleを適用（noseと同様に） if neck_scale != 1.0: neck_scaled = [ current_neck[0] + (orig_head_point[0] - orig_neck[0]) * neck_scale, current_neck[1] + (orig_head_point[1] - orig_neck[1]) * neck_scale ] else: # neck移動の影響のみ neck_movement = [current_neck[0] - orig_neck[0], current_neck[1] - orig_neck[1]] neck_scaled = [orig_head_point[0] + neck_movement[0], orig_head_point[1] + neck_movement[1]] # 次にhead_scaleを適用（new_noseを基準に） if head_scale != 1.0: head_scaled = [ new_nose[0] + (neck_scaled[0] - new_nose[0]) * head_scale, new_nose[1] + (neck_scaled[1] - new_nose[1]) * head_scale ] set_point(adjusted, KP[head_kp], head_scaled) else: set_point(adjusted, KP[head_kp], neck_scaled) else: # neck_scale=1.0 and head_scale=1.0の場合、neck移動の影響のみ適用 neck_movement = [current_neck[0] - orig_neck[0], current_neck[1] - orig_neck[1]] new_nose = [orig_nose[0] + neck_movement[0], orig_nose[1] + neck_movement[1]] set_point(adjusted, KP["Nose"], new_nose) for head_kp in ["REye", "LEye", "REar", "LEar"]: if head_kp in KP: orig_head_point = get_point(original, KP[head_kp]) if orig_head_point: head_moved = [orig_head_point[0] + neck_movement[0], orig_head_point[1] + neck_movement[1]] set_point(adjusted, KP[head_kp], head_moved) # 5. Arm adjustment. arm_scale remains the full-arm base scale; # upper/lower arm scales additionally affect each segment. if current_r_shoulder and current_l_shoulder: for side_prefix, current_shoulder, orig_shoulder in [ ("R", current_r_shoulder, orig_r_shoulder), ("L", current_l_shoulder, orig_l_shoulder) ]: if not orig_shoulder: continue orig_elbow = get_point(original, KP[f"{side_prefix}Elbow"]) orig_wrist = get_point(original, KP[f"{side_prefix}Wrist"]) if orig_elbow: new_elbow = [ current_shoulder[0] + (orig_elbow[0] - orig_shoulder[0]) * arm_scale * upper_arm_scale, current_shoulder[1] + (orig_elbow[1] - orig_shoulder[1]) * arm_scale * upper_arm_scale ] set_point(adjusted, KP[f"{side_prefix}Elbow"], new_elbow) else: new_elbow = None if orig_wrist: if orig_elbow and new_elbow: new_wrist = [ new_elbow[0] + (orig_wrist[0] - orig_elbow[0]) * arm_scale * lower_arm_scale, new_elbow[1] + (orig_wrist[1] - orig_elbow[1]) * arm_scale * lower_arm_scale ] else: new_wrist = [ current_shoulder[0] + (orig_wrist[0] - orig_shoulder[0]) * arm_scale * lower_arm_scale, current_shoulder[1] + (orig_wrist[1] - orig_shoulder[1]) * arm_scale * lower_arm_scale ] set_point(adjusted, KP[f"{side_prefix}Wrist"], new_wrist) # 6. Leg adjustment (from original leg joints, based on position after pelvis adjustment) current_r_hip = get_point(adjusted, KP["RHip"]) current_l_hip = get_point(adjusted, KP["LHip"]) for side_prefix, current_hip, orig_hip in [("R", current_r_hip, orig_r_hip), ("L", current_l_hip, orig_l_hip)]: if not current_hip or not orig_hip: continue orig_knee = get_point(original, KP[f"{side_prefix}Knee"]) orig_ankle = get_point(original, KP[f"{side_prefix}Ankle"]) if orig_knee: new_knee = [ current_hip[0] + (orig_knee[0] - orig_hip[0]) * leg_scale * thigh_scale, current_hip[1] + (orig_knee[1] - orig_hip[1]) * leg_scale * thigh_scale ] set_point(adjusted, KP[f"{side_prefix}Knee"], new_knee) else: new_knee = None if orig_ankle: if orig_knee and new_knee: new_ankle = [ new_knee[0] + (orig_ankle[0] - orig_knee[0]) * leg_scale * lower_leg_scale, new_knee[1] + (orig_ankle[1] - orig_knee[1]) * leg_scale * lower_leg_scale ] else: new_ankle = [ current_hip[0] + (orig_ankle[0] - orig_hip[0]) * leg_scale * lower_leg_scale, current_hip[1] + (orig_ankle[1] - orig_hip[1]) * leg_scale * lower_leg_scale ] set_point(adjusted, KP[f"{side_prefix}Ankle"], new_ankle) # 7. Toe/heel adjustment (ankle-based leg_scale scaling) current_l_ankle = get_point(adjusted, KP["LAnkle"]) current_r_ankle = get_point(adjusted, KP["RAnkle"]) orig_l_ankle = get_point(original, KP["LAnkle"]) orig_r_ankle = get_point(original, KP["RAnkle"]) if len(adjusted) >= 60: # Check if toe/heel keypoints exist # Toe/heel keypoint definitions (based on actual data structure) # 18: RBigToe (right foot toe), 19: LBigToe (left foot toe) TOE_HEEL_MAPPING = { 18: ("RBigToe", current_r_ankle, orig_r_ankle), # Right toe -> right ankle reference 19: ("LBigToe", current_l_ankle, orig_l_ankle), # Left toe -> left ankle reference } for idx, (name, current_ankle, orig_ankle) in TOE_HEEL_MAPPING.items(): keypoint_start = idx * 3 if (keypoint_start + 2 < len(original) and original[keypoint_start + 2] > 0 and current_ankle and orig_ankle): # Only if both ankle and toe exist orig_toe_heel = [original[keypoint_start], original[keypoint_start + 1]] orig_relative = [orig_toe_heel[0] - orig_ankle[0], orig_toe_heel[1] - orig_ankle[1]] scaled_relative = [orig_relative[0] * leg_scale * feet_scale, orig_relative[1] * leg_scale * feet_scale] new_toe_heel = [current_ankle[0] + scaled_relative[0], current_ankle[1] + scaled_relative[1]] # Update toe/heel position adjusted[keypoint_start] = new_toe_heel[0] adjusted[keypoint_start + 1] = new_toe_heel[1] # Keep confidence unchanged return adjusted def _adjust_face_keypoints(self, keypoints, canvas_width, canvas_height, **params): """ Face keypointsの調整処理 顔の各パーツ（目、眉、口、鼻）の調整 """ if not keypoints or len(keypoints) < 210: # 70 face keypoints * 3 = 210 return keypoints # Get parameters eye_distance_scale = params.get("eye_distance_scale", 1.0) eye_height = params.get("eye_height", 0.0) eyebrow_height = params.get("eyebrow_height", 0.0) left_eye_scale = params.get("left_eye_scale", 1.0) right_eye_scale = params.get("right_eye_scale", 1.0) left_eyebrow_scale = params.get("left_eyebrow_scale", 1.0) right_eyebrow_scale = params.get("right_eyebrow_scale", 1.0) mouth_scale = params.get("mouth_scale", 1.0) nose_scale_face = params.get("nose_scale_face", 1.0) face_shape_scale = params.get("face_shape_scale", 1.0) # Do nothing if all are default values if (eye_distance_scale == 1.0 and eye_height == 0.0 and eyebrow_height == 0.0 and left_eye_scale == 1.0 and right_eye_scale == 1.0 and left_eyebrow_scale == 1.0 and right_eyebrow_scale == 1.0 and mouth_scale == 1.0 and nose_scale_face == 1.0 and face_shape_scale == 1.0): return keypoints adjusted = keypoints.copy() # OpenPose face keypoint groups (standard definition) FACE_KP_GROUPS = { "Left_Eye": list(range(42, 48)), # 左目 (42-47) "Right_Eye": list(range(36, 42)), # 右目 (36-41) "Left_Eyebrow": list(range(22, 27)), # 左眉 (22-26) "Right_Eyebrow": list(range(17, 22)), # 右眉 (17-21) "Mouth": list(range(48, 68)), # 口 (48-67) "Nose_Face": list(range(27, 36)), # 鼻 (27-35) "Face_Shape": list(range(0, 17)) # 顔の輪郭 (0-16) } GROUP_SCALES = { "Left_Eye": left_eye_scale, "Right_Eye": right_eye_scale, "Left_Eyebrow": left_eyebrow_scale, "Right_Eyebrow": right_eyebrow_scale, "Mouth": mouth_scale, "Nose_Face": nose_scale_face, "Face_Shape": face_shape_scale } # 顔の中心を計算 (鼻の先端付近を使用) if len(adjusted) >= 93: # nose tip around index 30 * 3 = 90 face_center_x = adjusted[90] # nose tip x face_center_y = adjusted[91] # nose tip y else: face_center_x = canvas_width / 2 face_center_y = canvas_height / 2 # 各顔パーツのスケーリング for group_name, indices in FACE_KP_GROUPS.items(): scale_factor = GROUP_SCALES.get(group_name, 1.0) if scale_factor != 1.0: # Eye groups: use their own face keypoint center for scaling if group_name in ["Left_Eye", "Right_Eye"]: # Calculate current face eye center (centroid of eye keypoints) valid_points = [] for idx in indices: if idx * 3 + 2 < len(adjusted) and adjusted[idx * 3 + 2] > 0: valid_points.append((adjusted[idx * 3], adjusted[idx * 3 + 1])) if valid_points: # Eye center as scaling origin eye_center_x = sum(p[0] for p in valid_points) / len(valid_points) eye_center_y = sum(p[1] for p in valid_points) / len(valid_points) # Scale around the eye's own center for idx in indices: if idx * 3 + 2 < len(adjusted) and adjusted[idx * 3 + 2] > 0: x, y = adjusted[idx * 3], adjusted[idx * 3 + 1] # Scale from eye center rel_x = (x - eye_center_x) * scale_factor rel_y = (y - eye_center_y) * scale_factor # Keep centered at eye center adjusted[idx * 3] = eye_center_x + rel_x adjusted[idx * 3 + 1] = eye_center_y + rel_y else: # Other face parts use nose tip as center for idx in indices: if idx * 3 + 2 < len(adjusted) and adjusted[idx * 3 + 2] > 0: x, y = adjusted[idx * 3], adjusted[idx * 3 + 1] # Scale from face center rel_x = (x - face_center_x) * scale_factor rel_y = (y - face_center_y) * scale_factor adjusted[idx * 3] = face_center_x + rel_x adjusted[idx * 3 + 1] = face_center_y + rel_y # eye_height調整（目の位置を上下に移動） if eye_height != 0.0: for group_name in ["Left_Eye", "Right_Eye"]: for idx in FACE_KP_GROUPS[group_name]: if idx * 3 + 2 < len(adjusted) and adjusted[idx * 3 + 2] > 0: adjusted[idx * 3 + 1] += eye_height # eyebrow_height調整（眉の位置を上下に移動） if eyebrow_height != 0.0: for group_name in ["Left_Eyebrow", "Right_Eyebrow"]: for idx in FACE_KP_GROUPS[group_name]: if idx * 3 + 2 < len(adjusted) and adjusted[idx * 3 + 2] > 0: adjusted[idx * 3 + 1] += eyebrow_height # eye_distance_scale調整（目の間隔を調整） if eye_distance_scale != 1.0: # 左右の目の中心を計算 left_eye_center_x = left_eye_center_y = 0 right_eye_center_x = right_eye_center_y = 0 left_count = right_count = 0 for idx in FACE_KP_GROUPS["Left_Eye"]: if idx * 3 + 2 < len(adjusted) and adjusted[idx * 3 + 2] > 0: left_eye_center_x += adjusted[idx * 3] left_eye_center_y += adjusted[idx * 3 + 1] left_count += 1 for idx in FACE_KP_GROUPS["Right_Eye"]: if idx * 3 + 2 < len(adjusted) and adjusted[idx * 3 + 2] > 0: right_eye_center_x += adjusted[idx * 3] right_eye_center_y += adjusted[idx * 3 + 1] right_count += 1 if left_count > 0 and right_count > 0: left_eye_center_x /= left_count left_eye_center_y /= left_count right_eye_center_x /= right_count right_eye_center_y /= right_count # 目の間の中点 eyes_center_x = (left_eye_center_x + right_eye_center_x) / 2 eyes_center_y = (left_eye_center_y + right_eye_center_y) / 2 # Scale each eye away from center point for group_name, center_x, center_y in [ ("Left_Eye", left_eye_center_x, left_eye_center_y), ("Right_Eye", right_eye_center_x, right_eye_center_y) ]: for idx in FACE_KP_GROUPS[group_name]: if idx * 3 + 2 < len(adjusted) and adjusted[idx * 3 + 2] > 0: # Scale direction from eye center to overall center rel_x = (center_x - eyes_center_x) * eye_distance_scale rel_y = (center_y - eyes_center_y) * eye_distance_scale # 個々のキーポイントも同じ方向に移動 point_rel_x = adjusted[idx * 3] - center_x point_rel_y = adjusted[idx * 3 + 1] - center_y adjusted[idx * 3] = eyes_center_x + rel_x + point_rel_x adjusted[idx * 3 + 1] = eyes_center_y + rel_y + point_rel_y return adjusted def _adjust_hand_keypoints(self, keypoints, canvas_width, canvas_height, wrist_movement=None, **params): """ Hand keypointsの調整処理 手首を基準としたスケーリング + 腕の動きに連動した位置調整 Args: wrist_movement: [dx, dy] 手首の移動量（腕のスケーリングによる） """ if not keypoints or len(keypoints) < 63: # 21 keypoints * 3 = 63 return keypoints hands_scale = params.get("hands_scale", 1.0) # Set default value if wrist_movement is None if wrist_movement is None: wrist_movement = [0.0, 0.0] # Do nothing if hands_scale is 1.0 and wrist_movement is 0 if hands_scale == 1.0 and wrist_movement[0] == 0.0 and wrist_movement[1] == 0.0: return keypoints adjusted = keypoints.copy() # 手首は index 0 (OpenPose hand keypoint standard) wrist_x = adjusted[0] wrist_y = adjusted[1] wrist_conf = adjusted[2] if wrist_conf <= 0: # Move entire hand even when wrist is not detected if wrist_movement[0] != 0.0 or wrist_movement[1] != 0.0: adjusted_len = len(adjusted) for i in range(0, adjusted_len, 3): if i + 2 < adjusted_len and adjusted[i + 2] > 0: adjusted[i] += wrist_movement[0] adjusted[i + 1] += wrist_movement[1] return adjusted # Step 1: 手首を基準として hands_scale でスケーリング if hands_scale != 1.0: adjusted_len = len(adjusted) for i in range(3, adjusted_len, 3): # Start from joints other than wrist if i + 2 < adjusted_len and adjusted[i + 2] > 0: x, y = adjusted[i], adjusted[i + 1] # Scale by relative position from wrist scaled_x = wrist_x + (x - wrist_x) * hands_scale scaled_y = wrist_y + (y - wrist_y) * hands_scale adjusted[i] = scaled_x adjusted[i + 1] = scaled_y # Step 2: 腕の動きに連動して手全体を移動 if wrist_movement[0] != 0.0 or wrist_movement[1] != 0.0: for i in range(0, len(adjusted), 3): # 手首も含めて全てのキーポイントを移動 if i + 2 < len(adjusted) and adjusted[i + 2] > 0: # 信頼度チェック adjusted[i] += wrist_movement[0] adjusted[i + 1] += wrist_movement[1] return adjusted def _apply_global_transform(self, person, canvas_width, canvas_height, overall_scale, rotate_angle, translate_x, translate_y): """ 全体変換（回転・移動）を適用 """ if overall_scale == 1.0 and rotate_angle == 0.0 and translate_x == 0.0 and translate_y == 0.0: return # 変換不要 center_x = canvas_width / 2 center_y = canvas_height / 2 # 回転角度をラジアンに変換 angle_rad = math.radians(rotate_angle) cos_a = math.cos(angle_rad) sin_a = math.sin(angle_rad) # 各キーポイント配列に変換を適用 for keypoint_type in ["pose_keypoints_2d", "face_keypoints_2d", "hand_left_keypoints_2d", "hand_right_keypoints_2d"]: if keypoint_type in person and person[keypoint_type]: keypoints = person[keypoint_type] for i in range(0, len(keypoints), 3): if i + 2 < len(keypoints) and keypoints[i + 2] > 0: x, y = keypoints[i], keypoints[i + 1] # 中心を基準とした座標に変換 rel_x = x - center_x rel_y = y - center_y # overall_scaleを適用 if overall_scale != 1.0: rel_x *= overall_scale rel_y *= overall_scale # 回転変換 if rotate_angle != 0.0: new_x = rel_x * cos_a - rel_y * sin_a new_y = rel_x * sin_a + rel_y * cos_a else: new_x = rel_x new_y = rel_y # 移動変換と中心座標の復元 keypoints[i] = center_x + new_x + translate_x keypoints[i + 1] = center_y + new_y + translate_y # ノードクラスのエイリアス（ComfyUIでの参照用） NODE_CLASS_MAPPINGS = { "ProportionChangerParams": ProportionChangerParams, } NODE_DISPLAY_NAME_MAPPINGS = { "ProportionChangerParams": "ProportionChanger Params" }