Update utils.py

utils.py

@@ -2,7 +2,7 @@
 Utility functions for Phramer AI
 By Pariente AI, for MIA TV Series
 
-Enhanced with professional cinematography knowledge and multi-engine optimization
+Enhanced with professional cinematography knowledge and intelligent token economy
 """
 
 import re
@@ -130,14 +130,14 @@ def detect_scene_type_from_analysis(analysis_metadata: Dict[str, Any]) -> str:
 
 def apply_flux_rules(prompt: str, analysis_metadata: Optional[Dict[str, Any]] = None) -> str:
     """
-    Apply enhanced prompt optimization rules for multi-engine compatibility with condensation
+    Apply enhanced prompt optimization with cinematography knowledge and intelligent token economy
     
     Args:
         prompt: Raw prompt text from BAGEL analysis
         analysis_metadata: Enhanced metadata with cinematography suggestions
         
     Returns:
-        Optimized and condensed prompt for Flux, Midjourney, and other generative engines
+        Optimized prompt with professional cinematography terms and efficient token usage
     """
     if not prompt or not isinstance(prompt, str):
         return ""
@@ -150,10 +150,10 @@ def apply_flux_rules(prompt: str, analysis_metadata: Optional[Dict[str, Any]] =
     # Extract description part only (remove CAMERA_SETUP section if present)
     description_part = _extract_description_only(cleaned_prompt)
     
-    # NEW: Convert from descriptive to generative language
+    # NEW: Convert to generative language with cinematography angle detection
     if PROFESSIONAL_PHOTOGRAPHY_CONFIG.get("prompt_condensation", True):
-        description_part = _convert_to_generative_language(description_part)
-        logger.info("Converted to generative language")
+        description_part = _convert_to_cinematographic_language(description_part)
+        logger.info("Applied cinematographic language conversion")
     
     # Check if BAGEL provided intelligent camera setup with cinematography context
     camera_config = ""
@@ -177,15 +177,15 @@ def apply_flux_rules(prompt: str, analysis_metadata: Optional[Dict[str, Any]] =
     # Add style enhancement for multi-engine compatibility
     style_enhancement = _get_style_enhancement(scene_type, description_part.lower())
     
-    # NEW: Add mandatory generative keywords
-    mandatory_keywords = _get_mandatory_keywords(scene_type)
+    # NEW: Smart keyword insertion with token economy
+    smart_keywords = _apply_smart_keyword_insertion(description_part, camera_config, scene_type)
     
-    # Build final prompt: Description + Camera + Lighting + Style + Keywords
-    final_prompt = description_part + camera_config + lighting_enhancement + style_enhancement + mandatory_keywords
+    # Build final prompt: Description + Camera + Lighting + Style + Smart Keywords
+    final_prompt = description_part + camera_config + lighting_enhancement + style_enhancement + smart_keywords
     
-    # NEW: Final length optimization
+    # NEW: Final length optimization with token economy
     if PROFESSIONAL_PHOTOGRAPHY_CONFIG.get("prompt_optimization", {}).get("max_length"):
-        final_prompt = _optimize_prompt_length(final_prompt)
+        final_prompt = _optimize_prompt_with_token_economy(final_prompt)
     
     # Clean up formatting
     final_prompt = _clean_prompt_formatting(final_prompt)
@@ -224,9 +224,63 @@ def _extract_description_only(prompt: str) -> str:
     return description.strip()
 
 
-def _convert_to_generative_language(description: str) -> str:
-    """Convert descriptive analysis language to direct generative prompt language"""
+def _detect_camera_angles(description: str) -> List[str]:
+    """Detect camera angles and perspectives using professional cinematography knowledge"""
     try:
+        angles_detected = []
+        description_lower = description.lower()
+        
+        # Low angle (contrapicado) detection
+        low_angle_indicators = [
+            "looking up at", "from below", "upward angle", "towering", "looming",
+            "shot from ground level", "worm's eye", "low angle"
+        ]
+        if any(indicator in description_lower for indicator in low_angle_indicators):
+            angles_detected.append("low-angle shot")
+        
+        # High angle (picado) detection  
+        high_angle_indicators = [
+            "looking down", "from above", "overhead", "bird's eye", "aerial view",
+            "downward angle", "top-down", "high angle"
+        ]
+        if any(indicator in description_lower for indicator in high_angle_indicators):
+            angles_detected.append("high-angle shot")
+        
+        # Eye level detection
+        eye_level_indicators = [
+            "eye level", "straight on", "direct view", "level with"
+        ]
+        if any(indicator in description_lower for indicator in eye_level_indicators):
+            angles_detected.append("eye-level shot")
+        
+        # Dutch angle detection
+        dutch_indicators = [
+            "tilted", "angled", "diagonal", "off-kilter", "dutch angle"
+        ]
+        if any(indicator in description_lower for indicator in dutch_indicators):
+            angles_detected.append("dutch angle")
+        
+        # Perspective analysis for mixed angles
+        if ("foreground" in description_lower and "background" in description_lower):
+            if ("close" in description_lower or "prominent" in description_lower) and "blurred" in description_lower:
+                # Suggests foreground element shot from specific angle with background perspective
+                if not angles_detected:  # Only add if no specific angle detected
+                    angles_detected.append("shallow depth perspective")
+        
+        logger.info(f"Camera angles detected: {angles_detected}")
+        return angles_detected
+        
+    except Exception as e:
+        logger.warning(f"Camera angle detection failed: {e}")
+        return []
+
+
+def _convert_to_cinematographic_language(description: str) -> str:
+    """Convert descriptive analysis to cinematographic prompt language with angle detection"""
+    try:
+        # First detect camera angles
+        camera_angles = _detect_camera_angles(description)
+        
         generative = description
         
         # Remove descriptive introduction phrases
@@ -238,17 +292,13 @@ def _convert_to_generative_language(description: str) -> str:
             r'This is (?:a|an) (?:image|photograph|picture) (?:of|showing)',
             r'The setting (?:appears to be|is)',
             r'The scene (?:appears to be|is|shows)',
-            r'(?:In the background|In the foreground), (?:there are|there is)',
-            r'(?:The background|The foreground) (?:features|shows|contains)',
-            r'(?:There are|There is) [^,]+ (?:in the background|in the foreground)',
-            r'The overall (?:setting|atmosphere|mood) (?:suggests|indicates)',
         ]
         
         for pattern in descriptive_intros:
             generative = re.sub(pattern, '', generative, flags=re.IGNORECASE)
         
-        # Remove uncertainty phrases
-        uncertainty_phrases = [
+        # Remove uncertainty and verbose connector phrases
+        verbose_phrases = [
             r'possibly (?:a|an) ',
             r'appears to be (?:a|an) ',
             r'seems to be (?:a|an) ',
@@ -257,18 +307,26 @@ def _convert_to_generative_language(description: str) -> str:
             r'suggests (?:a|an) ',
             r'indicating (?:a|an) ',
             r'(?:possibly|apparently|seemingly|likely)',
+            r'which (?:is|are|creates|adds)',
+            r'(?:In the background|In the foreground), (?:there are|there is)',
+            r'(?:The background|The foreground) (?:features|shows|contains)',
+            r'(?:There are|There is) [^,]+ (?:in the background|in the foreground)',
+            r'The overall (?:setting|atmosphere|mood) (?:suggests|indicates)',
         ]
         
-        for pattern in uncertainty_phrases:
+        for pattern in verbose_phrases:
             generative = re.sub(pattern, '', generative, flags=re.IGNORECASE)
         
-        # Convert descriptive structure to noun phrases
-        structural_conversions = [
-            # "close-up of a X" -> "close-up X"
+        # Convert spatial relationships to cinematographic terms
+        spatial_conversions = [
+            # Background/foreground to cinematographic terms
+            (r'prominently displayed in (?:the )?foreground', 'foreground focus'),
+            (r'in (?:the )?foreground', 'foreground'),
+            (r'in (?:the )?background', 'background'),
+            (r'blurred (?:figures|people|objects)', 'bokeh blur'),
+            (r'out of focus', 'soft focus'),
+            # Convert descriptive structure to noun phrases
             (r'(?:close-up|medium shot|wide shot) of (?:a|an|the) ', r'close-up '),
-            # "blurred figures of people" -> "blurred people"
-            (r'(?:blurred )?(?:figures|silhouettes) of (\w+)', r'blurred \1'),
-            # "people walking on a sidewalk" -> "people walking on sidewalk"
             (r'(?:a|an|the) (\w+)', r'\1'),
             # Remove excessive connecting words
             (r'(?:, and|, with|, featuring)', ','),
@@ -277,7 +335,7 @@ def _convert_to_generative_language(description: str) -> str:
             (r'in (?:a|an|the) ', r'in '),
         ]
         
-        for pattern, replacement in structural_conversions:
+        for pattern, replacement in spatial_conversions:
             generative = re.sub(pattern, replacement, generative, flags=re.IGNORECASE)
         
         # Convert action descriptions to present participles
@@ -291,6 +349,11 @@ def _convert_to_generative_language(description: str) -> str:
         for pattern, replacement in action_conversions:
             generative = re.sub(pattern, replacement, generative, flags=re.IGNORECASE)
         
+        # Add detected camera angles at the beginning
+        if camera_angles:
+            angle_prefix = ", ".join(camera_angles)
+            generative = f"{angle_prefix}, {generative}"
+        
         # Clean up extra spaces and punctuation
         generative = re.sub(r'\s+', ' ', generative)
         generative = re.sub(r'^\s*,\s*', '', generative)  # Remove leading commas
@@ -302,47 +365,73 @@ def _convert_to_generative_language(description: str) -> str:
         if generative:
             generative = generative[0].upper() + generative[1:] if len(generative) > 1 else generative.upper()
         
-        logger.info(f"Converted descriptive to generative: {len(description)} → {len(generative)} chars")
+        logger.info(f"Cinematographic conversion: angles={len(camera_angles)}, {len(description)} → {len(generative)} chars")
         return generative
         
     except Exception as e:
-        logger.warning(f"Generative language conversion failed: {e}")
+        logger.warning(f"Cinematographic language conversion failed: {e}")
         return description
 
 
-def _get_mandatory_keywords(scene_type: str) -> str:
-    """Get mandatory generative keywords based on scene type"""
+def _apply_smart_keyword_insertion(description: str, camera_config: str, scene_type: str) -> str:
+    """Smart keyword insertion with token economy - avoid redundancy"""
     try:
-        mandatory = FLUX_RULES.get("mandatory_keywords", {})
-        
         keywords = []
         
-        # Add quality keywords
-        quality_keywords = mandatory.get("quality", [])
-        keywords.extend(quality_keywords)
+        # Token Economy Rule 1: If camera specs exist, skip "photorealistic" keywords
+        has_camera_specs = bool(re.search(r'(?:Canon|Sony|Leica|ARRI|RED|Hasselblad|Phase One)', camera_config))
+        has_lens_specs = bool(re.search(r'\d+mm.*f/[\d.]+', camera_config))
         
-        # Add technical keywords
-        technical_keywords = mandatory.get("technical", [])
-        keywords.extend(technical_keywords)
+        # Only add quality keywords if NO technical specs present
+        if not (has_camera_specs and has_lens_specs):
+            quality_keywords = FLUX_RULES.get("mandatory_keywords", {}).get("quality", [])
+            keywords.extend(quality_keywords[:2])  # Limit to 2 quality keywords max
+            logger.info("Added fallback quality keywords (no camera specs detected)")
+        else:
+            logger.info("Skipped redundant quality keywords (camera specs present)")
         
-        # Add scene-specific keywords
-        style_by_scene = mandatory.get("style_by_scene", {})
+        # Token Economy Rule 2: Scene-specific keywords only if they add value
+        style_by_scene = FLUX_RULES.get("mandatory_keywords", {}).get("style_by_scene", {})
         if scene_type in style_by_scene:
             scene_keywords = style_by_scene[scene_type]
-            keywords.extend(scene_keywords)
-        
-        if keywords:
-            return ", " + ", ".join(keywords)
+            
+            # Check if scene keywords are already implied by camera config or description
+            for keyword in scene_keywords:
+                if keyword.lower() not in camera_config.lower() and keyword.lower() not in description.lower():
+                    keywords.append(keyword)
+        
+        # Token Economy Rule 3: Technical keywords only if not redundant
+        technical_keywords = FLUX_RULES.get("mandatory_keywords", {}).get("technical", [])
+        for tech_keyword in technical_keywords:
+            # Skip "professional photography" if camera specs already indicate professional level
+            if tech_keyword == "professional photography" and has_camera_specs:
+                continue
+            # Skip "high resolution" if camera specs include resolution indicators
+            if tech_keyword == "high resolution" and has_camera_specs:
+                continue
+            keywords.append(tech_keyword)
+        
+        # Remove duplicates while preserving order
+        unique_keywords = []
+        for keyword in keywords:
+            if keyword not in unique_keywords:
+                unique_keywords.append(keyword)
+        
+        if unique_keywords:
+            result = ", " + ", ".join(unique_keywords)
+            logger.info(f"Smart keywords applied: {unique_keywords}")
+            return result
         else:
+            logger.info("No additional keywords needed (all redundant)")
             return ""
             
     except Exception as e:
-        logger.warning(f"Failed to get mandatory keywords: {e}")
+        logger.warning(f"Smart keyword insertion failed: {e}")
         return ""
 
 
-def _optimize_prompt_length(prompt: str) -> str:
-    """Optimize prompt length while preserving essential information"""
+def _optimize_prompt_with_token_economy(prompt: str) -> str:
+    """Optimize prompt length with intelligent token economy"""
     try:
         max_words = PROFESSIONAL_PHOTOGRAPHY_CONFIG.get("prompt_optimization", {}).get("max_length", 150)
         
@@ -350,34 +439,53 @@ def _optimize_prompt_length(prompt: str) -> str:
         if len(words) <= max_words:
             return prompt
         
-        # Keep essential parts: subject, camera setup, technical specs
+        # Priority preservation order for token economy
+        essential_patterns = [
+            # 1. Camera angles (highest priority)
+            r'(?:low-angle|high-angle|eye-level|dutch angle|bird\'s eye|worm\'s eye) shot',
+            # 2. Camera and lens specs
+            r'(?:Canon|Sony|Leica|ARRI|RED|Hasselblad|Phase One) [^,]+',
+            r'\d+mm[^,]*f/[\d.]+[^,]*',
+            r'ISO \d+',
+            # 3. Core subject and composition
+            r'(?:close-up|medium shot|wide shot|shallow depth)',
+            r'(?:foreground|background|bokeh)',
+            # 4. Scene-specific technical terms
+            r'(?:cinematic|anamorphic|telephoto|wide-angle)',
+        ]
+        
+        # Extract essential parts first
         essential_parts = []
-        current_part = []
+        remaining_text = prompt
         
-        for word in words:
-            current_part.append(word)
-            
-            # Keep camera and technical information
-            if any(tech in word.lower() for tech in ["shot", "lens", "f/", "iso", "mm"]):
-                essential_parts.extend(current_part)
-                current_part = []
-            # Keep quality keywords
-            elif any(qual in word.lower() for qual in ["photorealistic", "cinematic", "professional"]):
-                essential_parts.extend(current_part)
-                current_part = []
-        
-        # Add remaining words if under limit
-        remaining_words = max_words - len(essential_parts)
-        if remaining_words > 0 and current_part:
-            essential_parts.extend(current_part[:remaining_words])
-        
-        optimized = " ".join(essential_parts[:max_words])
-        logger.info(f"Optimized prompt length from {len(words)} to {len(essential_parts)} words")
+        for pattern in essential_patterns:
+            matches = re.findall(pattern, remaining_text, re.IGNORECASE)
+            for match in matches:
+                if match not in essential_parts:
+                    essential_parts.append(match)
+                # Remove from remaining text to avoid duplication
+                remaining_text = re.sub(re.escape(match), '', remaining_text, count=1, flags=re.IGNORECASE)
+        
+        # Add essential parts to start
+        optimized_words = []
+        for part in essential_parts:
+            optimized_words.extend(part.split())
+        
+        # Fill remaining space with most important remaining words
+        remaining_words = [w for w in remaining_text.split() if w.strip() and w not in optimized_words]
+        remaining_space = max_words - len(optimized_words)
+        
+        if remaining_space > 0:
+            optimized_words.extend(remaining_words[:remaining_space])
+        
+        optimized = " ".join(optimized_words[:max_words])
+        
+        logger.info(f"Token economy optimization: {len(words)} → {len(optimized_words)} words, preserved {len(essential_parts)} essential elements")
         
         return optimized
         
     except Exception as e:
-        logger.warning(f"Prompt length optimization failed: {e}")
+        logger.warning(f"Token economy optimization failed: {e}")
         return prompt
 
 
@@ -461,15 +569,15 @@ def _format_professional_camera_suggestion(bagel_camera: str, scene_type: str) -
             if composition_match:
                 camera_setup += f", {composition_match.group()}"
             
-            # Add scene-specific enhancement
+            # Scene-specific enhancement with token economy
             if scene_type == "cinematic":
-                result = f", Shot on {camera_setup}, cinematic photography"
+                result = f", Shot on {camera_setup}"  # Skip redundant "cinematic photography"
             elif scene_type == "portrait":
-                result = f", Shot on {camera_setup}, professional portrait photography"
+                result = f", Shot on {camera_setup}"  # Skip redundant "professional portrait photography"  
             else:
-                result = f", Shot on {camera_setup}, professional photography"
+                result = f", Shot on {camera_setup}"
                 
-            logger.info(f"Formatted camera setup: {result}")
+            logger.info(f"Formatted camera setup with token economy: {result}")
             return result
         else:
             # Fallback to enhanced config if parsing fails
@@ -484,12 +592,12 @@ def _get_enhanced_camera_config(scene_type: str, description_lower: str) -> str:
     """Get enhanced camera configuration with cinematography knowledge"""
     # Enhanced camera configurations with cinema equipment
     enhanced_configs = {
-        "cinematic": ", Shot on ARRI Alexa LF, 35mm anamorphic lens at f/2.8, ISO 400, cinematic framing, film grain, dramatic composition",
-        "portrait": ", Shot on Canon EOS R5, 85mm f/1.4 lens at f/2.8, ISO 200, rule of thirds composition, professional portrait photography",
-        "landscape": ", Shot on Phase One XT, 24-70mm f/4 lens at f/8, ISO 100, hyperfocal distance, leading lines composition, epic landscape photography",
-        "street": ", Shot on Leica M11, 35mm f/1.4 lens at f/2.8, ISO 800, decisive moment, candid composition, documentary street photography",
-        "architectural": ", Shot on Canon EOS R5, 24-70mm f/2.8 lens at f/8, ISO 100, symmetrical composition, perspective correction, architectural photography",
-        "commercial": ", Shot on Hasselblad X2D 100C, 90mm f/2.5 lens at f/4, ISO 100, centered composition, product photography"
+        "cinematic": ", Shot on ARRI Alexa LF, 35mm anamorphic lens at f/2.8, ISO 400",
+        "portrait": ", Shot on Canon EOS R5, 85mm f/1.4 lens at f/2.8, ISO 200, rule of thirds",
+        "landscape": ", Shot on Phase One XT, 24-70mm f/4 lens at f/8, ISO 100, hyperfocal distance",
+        "street": ", Shot on Leica M11, 35mm f/1.4 lens at f/2.8, ISO 800",
+        "architectural": ", Shot on Canon EOS R5, 24-70mm f/2.8 lens at f/8, ISO 100, symmetrical composition",
+        "commercial": ", Shot on Hasselblad X2D 100C, 90mm f/2.5 lens at f/4, ISO 100"
     }
     
     # Use enhanced config if available, otherwise fall back to FLUX_RULES
@@ -510,30 +618,27 @@ def _get_cinematography_lighting_enhancement(description_lower: str, camera_conf
     # Enhanced lighting based on scene type and cinematography knowledge
     if scene_type == "cinematic":
         if any(term in description_lower for term in ["dramatic", "moody", "dark"]):
-            return ", dramatic cinematic lighting with practical lights"
+            return ", dramatic lighting"
         else:
-            return ", professional cinematic lighting"
+            return ", cinematic lighting"
     elif scene_type == "portrait":
-        return ", professional studio lighting with subtle rim light"
+        return ", studio lighting"
     elif "dramatic" in description_lower or "chaos" in description_lower:
-        return FLUX_RULES["lighting_enhancements"]["dramatic"]
+        return ", dramatic lighting"
     else:
-        return FLUX_RULES["lighting_enhancements"]["default"]
+        return ""  # Skip redundant lighting terms
 
 
 def _get_style_enhancement(scene_type: str, description_lower: str) -> str:
-    """Get style enhancement for multi-engine compatibility"""
-    style_enhancements = FLUX_RULES.get("style_enhancements", {})
-    
+    """Get style enhancement for multi-engine compatibility with token economy"""
+    # Token economy: only add style if it adds unique value
     if scene_type == "cinematic":
         if "film grain" not in description_lower:
-            return ", " + style_enhancements.get("cinematic", "cinematic composition, film grain")
-    elif scene_type in ["portrait", "commercial"]:
-        return ", " + style_enhancements.get("photorealistic", "photorealistic rendering, ultra-detailed")
-    elif "editorial" in description_lower:
-        return ", " + style_enhancements.get("editorial", "editorial photography style")
+            return ", film grain"
+    elif scene_type == "architectural":
+        return ", clean lines"
     
-    return ""
+    return ""  # Skip redundant style terms
 
 
 def _clean_prompt_formatting(prompt: str) -> str:
@@ -593,12 +698,16 @@ def calculate_prompt_score(prompt: str, analysis_data: Optional[Dict[str, Any]]
     if re.search(r'\d+mm.*f/[\d.]+', prompt):
         tech_score += 5
     
+    # Camera angles (NEW - high value)
+    angle_terms = ['low-angle shot', 'high-angle shot', 'eye-level shot', 'dutch angle', 'bird\'s eye', 'worm\'s eye']
+    tech_score += sum(4 for term in angle_terms if term in prompt.lower())
+    
     # Anamorphic and specialized lenses
     if 'anamorphic' in prompt.lower():
         tech_score += 4
     
     # Professional terminology
-    tech_keywords = ['shot on', 'lens', 'photography', 'lighting', 'cinematic']
+    tech_keywords = ['shot on', 'lens', 'cinematography', 'lighting']
     for keyword in tech_keywords:
         if keyword in prompt.lower():
             tech_score += 2
@@ -609,19 +718,23 @@ def calculate_prompt_score(prompt: str, analysis_data: Optional[Dict[str, Any]]
         
     breakdown["technical_details"] = min(25, tech_score)
     
-    # Professional Cinematography (0-25 points) - NEW CATEGORY
+    # Professional Cinematography (0-25 points) - Enhanced with angle detection
     cinema_score = 0
     
+    # Camera angles (high value for professional cinematography)
+    angle_terms = ['low-angle', 'high-angle', 'eye-level', 'dutch angle', 'bird\'s eye', 'worm\'s eye']
+    cinema_score += sum(5 for term in angle_terms if term in prompt.lower())
+    
     # Professional lighting techniques
     lighting_terms = ['cinematic lighting', 'dramatic lighting', 'studio lighting', 'rim light', 'practical lights']
     cinema_score += sum(3 for term in lighting_terms if term in prompt.lower())
     
     # Composition techniques
-    composition_terms = ['composition', 'framing', 'depth of field', 'bokeh', 'rule of thirds']
+    composition_terms = ['composition', 'framing', 'depth of field', 'bokeh', 'rule of thirds', 'foreground', 'background']
     cinema_score += sum(2 for term in composition_terms if term in prompt.lower())
     
     # Cinematography style elements
-    style_terms = ['film grain', 'anamorphic', 'telephoto compression', 'wide-angle']
+    style_terms = ['film grain', 'anamorphic', 'telephoto compression', 'wide-angle', 'shallow depth']
     cinema_score += sum(3 for term in style_terms if term in prompt.lower())
     
     # Professional context bonus
@@ -630,24 +743,37 @@ def calculate_prompt_score(prompt: str, analysis_data: Optional[Dict[str, Any]]
     
     breakdown["professional_cinematography"] = min(25, cinema_score)
     
-    # Multi-Engine Optimization (0-25 points)
+    # Multi-Engine Optimization (0-25 points) - Token economy aware
     optimization_score = 0
     
-    # Check for multi-engine compatible elements
-    multi_engine_terms = ['photorealistic', 'ultra-detailed', 'professional photography', 'cinematic']
-    optimization_score += sum(3 for term in multi_engine_terms if term in prompt.lower())
+    # Check for technical specifications (more valuable than generic keywords)
+    if re.search(r'(?:Canon|Sony|Leica|ARRI|RED|Hasselblad|Phase One)', prompt):
+        optimization_score += 8  # Higher score for actual camera specs
     
-    # Technical specifications for generation
-    if any(camera in prompt for camera in FLUX_RULES["camera_configs"].values()):
-        optimization_score += 5
-        
-    # Lighting configuration
-    if any(lighting in prompt for lighting in FLUX_RULES["lighting_enhancements"].values()):
-        optimization_score += 4
-        
-    # Style enhancements
+    if re.search(r'\d+mm.*f/[\d.]+.*ISO \d+', prompt):
+        optimization_score += 7  # Complete technical specs
+    
+    # Token economy bonus: penalize redundant keywords
+    redundant_keywords = ['photorealistic', 'ultra-detailed', 'professional photography']
+    has_camera_specs = bool(re.search(r'(?:Canon|Sony|Leica|ARRI|RED)', prompt))
+    
+    if has_camera_specs:
+        # Bonus for NOT having redundant keywords when camera specs present
+        redundant_count = sum(1 for keyword in redundant_keywords if keyword in prompt.lower())
+        optimization_score += max(0, 5 - redundant_count * 2)  # Penalty for redundancy
+    else:
+        # If no camera specs, quality keywords are valuable
+        quality_keywords = sum(1 for keyword in redundant_keywords if keyword in prompt.lower())
+        optimization_score += min(5, quality_keywords * 2)
+    
+    # Scene-specific optimization
     if any(style in prompt for style in FLUX_RULES.get("style_enhancements", {}).values()):
         optimization_score += 3
+        
+    # Length efficiency bonus
+    word_count = len(prompt.split())
+    if word_count <= 120:  # Reward conciseness
+        optimization_score += 2
     
     breakdown["multi_engine_optimization"] = min(25, optimization_score)
     
@@ -716,11 +842,12 @@ def format_analysis_report(analysis_data: Dict[str, Any], processing_time: float
 **Professional Context:** {'✅ Applied' if has_cinema_context else '❌ Not Applied'}
 
 **🎯 OPTIMIZATIONS APPLIED:**
+✅ Camera angle detection
 ✅ Professional camera configuration
 ✅ Cinematography lighting setup  
-✅ Technical specifications
+✅ Token economy optimization
 ✅ Multi-engine compatibility
-✅ Cinema-quality enhancement
+✅ Redundancy elimination
 
 **⚡ Powered by Pariente AI for MIA TV Series**"""