""" Advanced AI Video Prompt Expander Node with Granular Aesthetic Controls Provides dropdown menus for all Wan 2.2 elements """ import os import re import random from typing import Tuple from .llm_backend import LLMBackend from .expansion_engine import PromptExpander from .utils import ( save_prompts_to_file, parse_keywords, format_breakdown, validate_positive_keywords ) class AIVideoPromptExpanderAdvanced: """ Advanced ComfyUI node with granular control over all Wan 2.2 aesthetic elements """ def __init__(self): self.expander = PromptExpander() self.type = "prompt_expansion_advanced" self.output_dir = "output/video_prompts" self._emphasis_store = [] # Store for emphasis syntax preservation @classmethod def INPUT_TYPES(cls): return { "required": { # Core inputs "basic_prompt": ("STRING", { "multiline": True, "default": "A cat playing piano in a cozy room", "tooltip": "Enter your prompt. Supports emphasis (keyword:1.5) and alternations {opt1|opt2}" }), # NEW: Operation mode "operation_mode": ([ "expand_from_idea", "refine_existing", "modify_style", "add_details" ], { "default": "expand_from_idea", "tooltip": ( "expand_from_idea: Take a short concept and expand it fully\n" "refine_existing: Polish and improve an existing prompt\n" "modify_style: Change the style/aesthetic of existing prompt\n" "add_details: Add more descriptive details to existing prompt" ) }), "preset": ([ "custom", "cinematic", "surreal", "action", "stylized", "noir", "random" ], { "default": "cinematic" }), "detail_level": ([ "concise", # ~150-200 words "moderate", # ~250-350 words "detailed", # ~400-500 words "exhaustive" # ~600-1000 words ], { "default": "detailed", "tooltip": ( "concise: Brief, essential details only\n" "moderate: Good balance of detail\n" "detailed: Rich, comprehensive description\n" "exhaustive: Maximum detail for cinematic quality" ) }), "creativity_mode": ([ "conservative", "balanced", "creative", "highly_creative" ], { "default": "balanced", "tooltip": ( "Conservative: Focused, predictable (temp 0.5)\n" "Balanced: Good variety (temp 0.7)\n" "Creative: More experimental (temp 0.85)\n" "Highly Creative: Maximum variety (temp 1.0)" ) }), # === REFERENCE IMAGE CONTROLS === "reference_mode": ([ "recreate_exact", "subject_only", "style_only", "color_palette_only", "action_only", "character_remix", "reimagine" ], { "default": "recreate_exact", "tooltip": ( "recreate_exact: Use image as exact reference for character, costume, and setting\n" "subject_only: Keep character identity, ignore background and lighting\n" "style_only: Match aesthetic and mood, create new subject\n" "color_palette_only: Extract and apply color scheme only\n" "action_only: Use the pose/action, change everything else\n" "character_remix: Keep character, place in new scenario\n" "reimagine: Loosely inspired by image, creative reinterpretation" ) }), # === SHOT STRUCTURE CONTROLS === "shot_structure": ([ "continuous_paragraph", "2_shot_structure", "3_shot_structure", "4_shot_structure" ], { "default": "3_shot_structure", "tooltip": ( "continuous_paragraph: Single flowing description (no shot breaks)\n" "2_shot_structure: Two distinct shots (Opening + Final Reveal)\n" "3_shot_structure: Three shots (Setup, Development, Finale) [Recommended]\n" "4_shot_structure: Four shots (Intro, Build, Climax, Resolution)" ) }), # === LIGHTING CONTROLS === "light_source": ([ "auto", "none", "sunny lighting", "artificial lighting", "moonlighting", "practical lighting", "firelighting", "fluorescent lighting", "overcast lighting", "mixed lighting", "ambient lighting", "reflected lighting", "softbox lighting", "camera flash", "neon lights", "striplight", "computer screen glow", "flashlight", "candlelight", "spotlight" ], { "default": "auto", "tooltip": "Primary source of illumination in the scene" }), "lighting_quality": ([ "auto", "none", "soft lighting", "hard lighting", "top lighting", "side lighting", "edge lighting", "rim lighting", "underlighting", "silhouette lighting", "backlighting", "low contrast lighting", "high contrast lighting", "spotlight effect", "dappled lighting", "cinematic lighting", "diffused lighting", "dramatic lighting" ], { "default": "auto", "tooltip": "Quality and style of lighting" }), "time_of_day": ([ "auto", "none", "sunrise time", "dawn time", "daylight", "daytime", "dusk time", "sunset time", "night time" ], { "default": "auto" }), # === CAMERA/SHOT CONTROLS === "shot_size": ([ "auto", "none", "extreme close-up shot", "close-up shot", "medium close-up shot", "medium shot", "medium wide shot", "wide shot", "extreme wide shot", "establishing shot" ], { "default": "auto" }), "composition": ([ "auto", "none", "center composition", "balanced composition", "left-weighted composition", "right-weighted composition", "symmetrical composition", "short-side composition", "rule of thirds" ], { "default": "auto" }), "lens": ([ "auto", "none", "wide-angle lens", "medium lens", "long-focus lens", "telephoto lens", "fisheye lens" ], { "default": "auto" }), "camera_angle": ([ "auto", "none", "eye-level shot", "high angle shot", "low angle shot", "dutch angle shot", "aerial shot", "bird's eye view", "over-the-shoulder shot", "top-down shot", "first-person POV", "profile close-up" ], { "default": "auto" }), "camera_movement": ([ "auto", "none", "static shot", "locked-off shot", "camera pushes in", "dolly in", "camera pulls back", "dolly out", "camera pans right", "camera pans left", "camera tilts up", "camera tilts down", "tracking shot", "arc shot", "crane shot", "camera cranes up", "camera cranes down", "handheld camera", "steadicam", "compound move", "whip pan", "camera orbits around subject", "smooth glide", "crash zoom in" ], { "default": "auto", "tooltip": "How the camera moves through the scene (Wan 2.2 optimized)" }), # === COLOR/STYLE CONTROLS === "color_tone": ([ "auto", "none", "warm colors", "cool colors", "saturated colors", "desaturated colors", "monochromatic", "black and white" ], { "default": "auto" }), "art_style": ([ "auto", "none", "Picasso style", "Van Gogh style", "Monet style", "Salvador Dali style", "Banksy style", "Andy Warhol style", "Rembrandt style", "Caravaggio style", "Studio Ghibli style", "Tim Burton style", "Wes Anderson style", "Pixar style", "Norman Rockwell style", "Edward Hopper style", "Renaissance style", "Baroque style", "Art Nouveau style", "Expressionist style", "Impressionist style", "Surrealist style", "Cubist style", "Pop Art style" ], { "default": "auto", "tooltip": "Apply the distinctive style of famous artists or art movements" }), "scene_detail": ([ "auto", "none", "simple scene", "clean scene", "detailed scene", "cluttered scene", "intricate detail", "minimalist", "maximalist" ], { "default": "auto", "tooltip": "Level of detail and complexity in the scene composition" }), "visual_style": ([ "auto", "none", "photorealistic", "cinematic", "3D cartoon style", "2D anime style", "pixel art style", "claymation style", "puppet animation", "felt style", "watercolor painting", "oil painting style", "pencil sketch", "comic book style", "line drawing" ], { "default": "auto" }), "visual_effect": ([ "auto", "none", "tilt-shift photography", "time-lapse", "slow motion", "motion blur", "depth of field", "bokeh", "lens flare", "film grain", "vignette" ], { "default": "auto" }), # === MOTION/EMOTION CONTROLS === "character_emotion": ([ "auto", "none", "angry", "fearful", "happy", "sad", "surprised", "confused", "determined", "thoughtful", "pensive", "excited", "calm", "anxious" ], { "default": "auto" }), # LLM Configuration "llm_backend": ([ "lm_studio", "ollama", "qwen3_vl" ], { "default": "lm_studio", "tooltip": ( "lm_studio: Uses currently loaded model in LM Studio\n" "ollama: Uses currently loaded model in Ollama\n" "qwen3_vl: Auto-detects local Qwen3-VL model (no API server needed)" ) }), "api_endpoint": ("STRING", { "default": "http://localhost:1234/v1", "multiline": False, "tooltip": ( "lm_studio/ollama: API endpoint URL\n" "qwen3_vl: Leave default, or specify custom model path like 'local:A:\\path\\to\\model'" ) }), # Keywords "positive_keywords": ("STRING", { "default": "", "multiline": True, "placeholder": "lora_trigger, keyword1, keyword2" }), "negative_keywords": ("STRING", { "default": "", "multiline": True, "placeholder": "unwanted_term1, unwanted_term2" }), # Output options "num_variations": ("INT", { "default": 1, "min": 1, "max": 3, "step": 1 }), "save_to_file": ("BOOLEAN", { "default": False }), "filename_base": ("STRING", { "default": "video_prompt_advanced", "multiline": False }) }, "optional": { # Optional image/video reference for image-to-video workflows "reference_image": ("IMAGE", { "tooltip": "Optional: Provide an image to analyze and incorporate into the prompt using Qwen3-VL" }), } } RETURN_TYPES = ("STRING", "STRING", "STRING", "STRING", "STRING", "STRING", "STRING") RETURN_NAMES = ( "positive_prompt_1", "positive_prompt_2", "positive_prompt_3", "negative_prompt", "breakdown", "status", "vision_caption" ) FUNCTION = "expand_prompt" CATEGORY = "Eric Prompt Enhancers" OUTPUT_NODE = True def expand_prompt( self, basic_prompt: str, operation_mode: str, preset: str, detail_level: str, creativity_mode: str, reference_mode: str, shot_structure: str, light_source: str, lighting_quality: str, time_of_day: str, shot_size: str, composition: str, lens: str, camera_angle: str, camera_movement: str, color_tone: str, art_style: str, scene_detail: str, visual_style: str, visual_effect: str, character_emotion: str, llm_backend: str, api_endpoint: str, positive_keywords: str, negative_keywords: str, num_variations: int, save_to_file: bool, filename_base: str, reference_image=None # Optional image input ) -> Tuple[str, str, str, str, str, str, str]: """ Main processing function with aesthetic controls """ try: # Map creativity mode to temperature temperature_map = { "conservative": 0.5, "balanced": 0.7, "creative": 0.85, "highly_creative": 1.0 } temperature = temperature_map.get(creativity_mode, 0.7) # Process alternations first (before LLM) basic_prompt = self._process_alternations(basic_prompt) # Preserve emphasis syntax before LLM processing basic_prompt = self._preserve_emphasis_syntax(basic_prompt) # === PASS 1: Vision Analysis (if image provided) === vision_caption = "" mode = "text-to-video" # Default if reference_image is not None: try: print(f"[Advanced Node] PASS 1: Analyzing reference image with Qwen3-VL...") # Get comprehensive image caption (no mode filtering yet) vision_caption = self._process_reference_image(reference_image) if vision_caption: mode = "image-to-video" print(f"[Advanced Node] ✓ Vision analysis complete: {len(vision_caption)} chars") print(f"[Advanced Node] Caption preview: {vision_caption[:200]}...") else: print(f"[Advanced Node] ⚠ Vision analysis returned empty - continuing without image context") except Exception as e: print(f"[Advanced Node] ⚠ Warning: Could not process image: {e}") print(f"[Advanced Node] Continuing with text-only mode...") # Continue without image context - graceful degradation elif reference_mode != "recreate_exact": # User set a reference_mode but didn't attach image - warn but continue print(f"[Advanced Node] ⚠ Warning: reference_mode is '{reference_mode}' but no image attached") print(f"[Advanced Node] Continuing in text-only mode...") # Parse keywords pos_kw_list = parse_keywords(positive_keywords) neg_kw_list = parse_keywords(negative_keywords) # Gather aesthetic controls aesthetic_controls = self._gather_aesthetic_controls( light_source, lighting_quality, time_of_day, shot_size, composition, lens, camera_angle, camera_movement, color_tone, art_style, scene_detail, visual_style, visual_effect, character_emotion ) # Initialize LLM backend (model_name auto-detected) llm = LLMBackend( backend_type=llm_backend, endpoint=api_endpoint, model_name=None, # Auto-detect for all backends temperature=temperature ) # Test connection conn_test = llm.test_connection() if not conn_test["success"]: error_msg = f"LLM Connection Failed: {conn_test['message']}" return ( basic_prompt, "", "", "", f"ERROR: {error_msg}", f"❌ {error_msg}", vision_caption if vision_caption else "No image provided" ) # === PASS 2: Smart LLM Expansion === print(f"[Advanced Node] PASS 2: Expanding prompt with LLM...") # Generate variations positive_prompts = [] breakdowns = [] for var_num in range(num_variations): # Build expansion prompts with: # - User's basic prompt # - Vision caption (if available) # - Reference mode instructions (how to apply vision caption) # - Aesthetic controls # - Creativity mode # - Shot structure system_prompt, user_prompt, breakdown_dict = self.expander.expand_prompt( basic_prompt=basic_prompt, preset=preset, tier=detail_level, # Map detail_level to tier mode=mode, positive_keywords=pos_kw_list, variation_seed=var_num if num_variations > 1 else None, aesthetic_controls=aesthetic_controls, shot_structure=shot_structure, creativity_mode=creativity_mode, vision_caption=vision_caption, # Pass 1 result reference_mode=reference_mode # How to apply vision caption ) # Call LLM with longer max_tokens for detailed output response = llm.send_prompt( system_prompt=system_prompt, user_prompt=user_prompt, max_tokens=3000 # Increased for more detail ) if not response["success"]: error_msg = response["error"] print(f"[Advanced Node] LLM expansion failed: {error_msg}") print(f"[Advanced Node] Full response: {response}") return ( basic_prompt, "", "", "", f"ERROR: {error_msg}", f"❌ {error_msg}", vision_caption if vision_caption else "No image provided" ) # Parse response parsed = self.expander.parse_llm_response(response["response"]) enhanced_prompt = parsed["prompt"] # Restore emphasis syntax after LLM processing enhanced_prompt = self._restore_emphasis_syntax(enhanced_prompt) # Ensure positive keywords are included if pos_kw_list: keywords_present, missing = validate_positive_keywords(pos_kw_list, enhanced_prompt) if missing: enhanced_prompt += f" {', '.join(missing)}" positive_prompts.append(enhanced_prompt) breakdowns.append(breakdown_dict) # Pad to 3 variations while len(positive_prompts) < 3: positive_prompts.append("") # Generate negative prompt with visual_style for Wan 2.2 optimization negative_prompt = self.expander.generate_negative_prompt( preset=preset, custom_negatives=neg_kw_list, mode=mode, visual_style=visual_style ) # Format breakdown breakdown_text = self._format_advanced_breakdown( breakdowns, basic_prompt, aesthetic_controls ) # Save to file if requested if save_to_file and positive_prompts[0]: metadata = { "preset": preset, "detail_level": detail_level, "operation_mode": operation_mode, "mode": mode, "backend": llm_backend, "model": llm.model_name or "auto-detected", "creativity_mode": creativity_mode, "temperature": temperature, "variation_num": num_variations, "original_prompt": basic_prompt, "aesthetic_controls": aesthetic_controls, "had_image_reference": reference_image is not None } save_result = save_prompts_to_file( positive_prompt=positive_prompts[0], negative_prompt=negative_prompt, breakdown=breakdown_text, metadata=metadata, filename_base=filename_base, output_dir=self.output_dir ) if save_result["success"]: file_status = f"💾 Saved to: {save_result['filepath']}" else: file_status = f"⚠️ Save failed: {save_result['error']}" else: file_status = "Not saved" # Build status with aesthetic controls summary controls_summary = self._summarize_controls(aesthetic_controls) mode_display = f"Mode: {mode}" + (" (with image)" if reference_image is not None else "") vision_status = f" | Vision: {len(vision_caption)} chars" if vision_caption else "" status = f"✅ Generated {num_variations} variation(s) | {operation_mode} | Detail: {detail_level} | Preset: {preset}\n{mode_display}{vision_status}\n{controls_summary}\n{file_status}" return ( positive_prompts[0], positive_prompts[1], positive_prompts[2], negative_prompt, breakdown_text, status, vision_caption if vision_caption else "No image provided" ) except Exception as e: error_msg = f"Unexpected error: {str(e)}" # Try to preserve vision_caption if it exists caption_output = vision_caption if 'vision_caption' in locals() and vision_caption else "No image provided" return ( basic_prompt if 'basic_prompt' in locals() else "", "", "", "", f"ERROR: {error_msg}", f"❌ {error_msg}", caption_output ) def _gather_aesthetic_controls( self, light_source: str, lighting_quality: str, time_of_day: str, shot_size: str, composition: str, lens: str, camera_angle: str, camera_movement: str, color_tone: str, art_style: str, scene_detail: str, visual_style: str, visual_effect: str, character_emotion: str ) -> dict: """Gather all non-auto/none aesthetic controls""" controls = {} if light_source not in ["auto", "none"]: controls["light_source"] = light_source if lighting_quality not in ["auto", "none"]: controls["lighting_quality"] = lighting_quality if time_of_day not in ["auto", "none"]: controls["time_of_day"] = time_of_day if shot_size not in ["auto", "none"]: controls["shot_size"] = shot_size if composition not in ["auto", "none"]: controls["composition"] = composition if lens not in ["auto", "none"]: controls["lens"] = lens if camera_angle not in ["auto", "none"]: controls["camera_angle"] = camera_angle if camera_movement not in ["auto", "none"]: controls["camera_movement"] = camera_movement if color_tone not in ["auto", "none"]: controls["color_tone"] = color_tone if art_style not in ["auto", "none"]: controls["art_style"] = art_style if scene_detail not in ["auto", "none"]: controls["scene_detail"] = scene_detail if visual_style not in ["auto", "none"]: controls["visual_style"] = visual_style if visual_effect not in ["auto", "none"]: controls["visual_effect"] = visual_effect if character_emotion not in ["auto", "none"]: controls["character_emotion"] = character_emotion return controls def _summarize_controls(self, controls: dict) -> str: """Create summary of applied controls""" if not controls: return "Controls: All Auto" summary_parts = [] for key, value in controls.items(): label = key.replace("_", " ").title() summary_parts.append(f"{label}: {value}") return "Controls: " + ", ".join(summary_parts) def _format_advanced_breakdown( self, breakdowns: list, original: str, aesthetic_controls: dict ) -> str: """Format breakdown with aesthetic controls""" if not breakdowns: return "No breakdown available" lines = [ "=" * 70, "ADVANCED PROMPT EXPANSION BREAKDOWN", "=" * 70, f"\nOriginal Input:\n{original}\n", f"\nDetected Tier: {breakdowns[0].get('detected_tier', 'N/A')}", f"Applied Preset: {breakdowns[0].get('applied_preset', 'N/A')}", f"Mode: {breakdowns[0].get('mode', 'N/A')}", ] if breakdowns[0].get('positive_keywords'): lines.append(f"Required Keywords: {', '.join(breakdowns[0]['positive_keywords'])}") if aesthetic_controls: lines.append("\nUser-Specified Aesthetic Controls:") for key, value in aesthetic_controls.items(): label = key.replace("_", " ").title() lines.append(f" - {label}: {value}") lines.append("\n" + "=" * 70) return "\n".join(lines) def _process_alternations(self, text: str) -> str: """ Process alternation syntax {option1|option2|option3} Replaces with randomly chosen option """ import re import random # Pattern to match {option1|option2|option3} pattern = r'\{([^{}]+)\}' def replace_alternation(match): options = match.group(1).split('|') # Strip whitespace from each option options = [opt.strip() for opt in options] return random.choice(options) # Keep replacing until no more alternations found (handles nested cases) max_iterations = 10 # Prevent infinite loops iteration = 0 while '{' in text and '|' in text and iteration < max_iterations: new_text = re.sub(pattern, replace_alternation, text) if new_text == text: # No more changes break text = new_text iteration += 1 return text def _preserve_emphasis_syntax(self, text: str) -> str: """ Protect emphasis syntax (keyword:1.5) from being modified Replaces temporarily with placeholders during LLM processing """ import re # Pattern to match (text:number) emphasis syntax # This matches things like (dark skin:1.5) or (hair:0.8) pattern = r'\(([^():]+):(\d+\.?\d*)\)' # Find all emphasis patterns emphasis_patterns = re.findall(pattern, text) # Store original patterns self._emphasis_store = [] # Replace with placeholders def replace_emphasis(match): full_match = match.group(0) placeholder = f"__EMPHASIS_{len(self._emphasis_store)}__" self._emphasis_store.append(full_match) return placeholder text = re.sub(pattern, replace_emphasis, text) return text def _restore_emphasis_syntax(self, text: str) -> str: """ Restore emphasis syntax that was protected """ if not hasattr(self, '_emphasis_store'): return text # Restore placeholders with original emphasis syntax for i, original in enumerate(self._emphasis_store): placeholder = f"__EMPHASIS_{i}__" text = text.replace(placeholder, original) # Clear the store self._emphasis_store = [] return text def _apply_operation_mode(self, prompt: str, operation_mode: str, image_context: str = "") -> str: """ Apply operation mode to modify how the prompt is processed """ if operation_mode == "expand_from_idea": # Default behavior - treat as short concept to expand return prompt + image_context elif operation_mode == "refine_existing": # Polish and improve without major changes instruction = "\n\n[INSTRUCTION: This is an existing prompt to refine. Keep the core content but improve clarity, flow, and descriptive quality. Don't dramatically change the concept or add major new elements.]" return prompt + instruction + image_context elif operation_mode == "modify_style": # Change aesthetic/style while keeping subject instruction = "\n\n[INSTRUCTION: This is an existing prompt. Keep the main subject and action, but modify the style, mood, cinematography, and aesthetic treatment according to the selected preset and controls.]" return prompt + instruction + image_context elif operation_mode == "add_details": # Add more descriptive elements instruction = "\n\n[INSTRUCTION: This is an existing prompt that needs more detail. Keep everything that's already there and add richer descriptions, atmospheric details, and sensory elements.]" return prompt + instruction + image_context return prompt + image_context def _build_reference_mode_instruction(self, reference_mode: str) -> str: """ Build explicit instruction for how to use the reference image based on mode Follows Wan 2.2 image-to-video best practices """ mode_instructions = { "recreate_exact": ( "[REFERENCE MODE: RECREATE EXACT]\n" "Use the provided image as the exact character and costume reference. " "Keep the same face, hair, outfit, lighting, and overall aesthetic. " "Animate this character/scene without changing identity or appearance. " "Match the visual style, mood, and composition of the reference image." ), "subject_only": ( "[REFERENCE MODE: SUBJECT ONLY]\n" "Preserve ONLY the subject's face, body identity, and core appearance from the reference image. " "Ignore the original background, lighting, and environment. " "Place this character in the new scene described by the prompt with new lighting and atmosphere. " "Keep character identity consistent but change everything else." ), "style_only": ( "[REFERENCE MODE: STYLE TRANSFER]\n" "Match the lighting, color palette, visual aesthetic, and cinematic mood of the reference image. " "Create a completely new subject, character, and scene, but apply the same artistic style, " "color grading, lighting quality, and atmospheric treatment seen in the reference." ), "color_palette_only": ( "[REFERENCE MODE: COLOR PALETTE ONLY]\n" "Extract and apply the dominant color scheme from the reference image. " "Use the same hues, saturation levels, and color relationships. " "Create an entirely new subject and scene, but maintain color harmony with the reference palette. " "Ignore composition, lighting style, and subject matter from the reference." ), "action_only": ( "[REFERENCE MODE: ACTION/POSE ONLY]\n" "Recreate the pose, gesture, body language, and action/movement from the reference image. " "Change the character identity, environment, lighting, costume, and visual style completely. " "Keep only the physical positioning and motion dynamic from the reference." ), "character_remix": ( "[REFERENCE MODE: CHARACTER REMIX]\n" "Keep the character's core identity (face, build, personality traits) from the reference image. " "Place them in a completely new scenario, environment, time period, or genre as described in the prompt. " "Change their outfit, the lighting, the setting, and the mood, but maintain character recognition. " "Adapt the character to fit the new context while preserving their essential identity." ), "reimagine": ( "[REFERENCE MODE: REIMAGINE]\n" "Use the reference image as loose inspiration for a creative reinterpretation. " "Take the core concept, mood, or theme and reimagine it in a new way. " "Feel free to change subject, style, setting, and execution while maintaining thematic connection. " "This is the most creative mode - interpret the essence freely and combine with the prompt." ) } return mode_instructions.get(reference_mode, mode_instructions["recreate_exact"]) def _process_reference_image(self, image_tensor): """ PASS 1: Comprehensive Vision Analysis using Qwen3-VL Get complete image description without reference_mode filtering. The LLM will apply reference_mode logic in Pass 2. Returns: Complete image caption string or None if error """ try: import torch import numpy as np from PIL import Image from .qwen3_vl_backend import caption_with_qwen3_vl # Convert ComfyUI image format (B,H,W,C) to PIL Image if isinstance(image_tensor, torch.Tensor): # Take first image if batch img_np = image_tensor[0].cpu().numpy() # Convert from 0-1 float to 0-255 uint8 img_np = (img_np * 255).astype(np.uint8) pil_image = Image.fromarray(img_np) else: return None # Comprehensive analysis prompt - get ALL details # Reference mode filtering will happen in Pass 2 (LLM expansion) comprehensive_prompt = """Analyze this image in complete detail for video prompt generation. Provide a thorough description covering: **SUBJECT/CHARACTER:** - Facial features, expression, age, gender, distinctive traits - Hair style, length, color, texture - Body type, build, posture, pose - Clothing: style, color, material, accessories, condition - Personality or mood visible in expression - Any actions or gestures being performed **ENVIRONMENT/SETTING:** - Location type and specific details - Background elements and spatial layout - Environmental context and atmosphere - Props, objects, or decorative elements - Scale and depth of space **LIGHTING & COLOR:** - Light source direction, quality, intensity - Color temperature (warm/cool) - Shadows, highlights, contrast - Color palette: dominant colors, accents, saturation - Overall color mood **COMPOSITION & STYLE:** - Camera angle and framing - Compositional elements and balance - Artistic style (photorealistic, illustrated, etc.) - Visual quality and rendering - Cinematic or aesthetic qualities - Mood and emotional tone Be comprehensive and detailed - this caption will be used to generate video prompts.""" caption_result = caption_with_qwen3_vl(pil_image, comprehensive_prompt) if caption_result["success"]: return caption_result["caption"] else: print(f"[Advanced Node] Qwen3-VL error: {caption_result.get('error', 'Unknown error')}") return None except Exception as e: print(f"[Advanced Node] Error processing image: {e}") import traceback traceback.print_exc() return None # For testing if __name__ == "__main__": node = AIVideoPromptExpanderAdvanced() print("Advanced node initialized with", len(node.INPUT_TYPES()["required"]), "parameters")