Update app.py

app.py

@@ -28,265 +28,360 @@ def get_device():
 
 DEVICE = get_device()
 
-class DeepFluxAnalyzer:
+class MaximumFluxAnalyzer:
     """
-    Deep analysis engine that understands image content and applies Flux rules intelligently
+    Maximum depth analysis engine - extracts EVERYTHING possible from images
     """
     
     def __init__(self):
         self.forbidden_elements = ["++", "weights", "white background [en dev]"]
         
-        # Deep vocabulary for intelligent analysis
-        self.age_descriptors = {
-            "young": ["young", "youthful", "fresh-faced"],
-            "middle": ["middle-aged", "mature"], 
-            "elderly": ["elderly", "aged", "distinguished", "weathered"]
+        # EXPANDED VOCABULARIES FOR MAXIMUM DETECTION
+        
+        self.age_keywords = {
+            "elderly": ["old", "elderly", "aged", "senior", "mature", "weathered", "wrinkled", "gray", "grey", "white hair", "silver", "graying", "ancient", "vintage"],
+            "middle": ["middle-aged", "adult", "grown", "middle", "forties", "fifties"],
+            "young": ["young", "youth", "teenage", "boy", "girl", "child", "kid", "adolescent"]
         }
         
         self.facial_features = {
-            "beard": ["bearded", "with a full beard", "with facial hair", "with a silver beard", "with a gray beard"],
-            "glasses": ["wearing glasses", "with wire-frame glasses", "with spectacles", "with eyeglasses"],
-            "eyes": ["intense gaze", "piercing eyes", "contemplative expression", "focused stare"]
+            "beard_full": ["beard", "bearded", "facial hair", "full beard", "thick beard", "heavy beard"],
+            "beard_color": ["gray beard", "grey beard", "silver beard", "white beard", "salt pepper", "graying beard"],
+            "mustache": ["mustache", "moustache", "facial hair"],
+            "glasses": ["glasses", "spectacles", "eyeglasses", "wire-frame", "rimmed glasses", "reading glasses"],
+            "eyes": ["eyes", "gaze", "stare", "looking", "piercing", "intense", "deep eyes"],
+            "wrinkles": ["wrinkled", "lines", "aged", "weathered", "creased"],
+            "expression": ["serious", "contemplative", "thoughtful", "stern", "wise", "solemn"]
+        }
+        
+        self.religious_cultural = {
+            "jewish": ["jewish", "orthodox", "hasidic", "rabbi", "religious", "traditional", "ceremonial"],
+            "hat_types": ["hat", "cap", "yarmulke", "kippah", "black hat", "traditional hat", "religious headwear"],
+            "clothing": ["suit", "jacket", "formal", "black clothing", "traditional dress", "religious attire"]
+        }
+        
+        self.hair_descriptors = {
+            "color": ["gray", "grey", "silver", "white", "black", "brown", "blonde", "salt and pepper"],
+            "texture": ["curly", "wavy", "straight", "thick", "thin", "coarse", "fine"],
+            "style": ["long", "short", "receding", "balding", "full head"]
         }
         
-        self.clothing_religious = {
-            "hat": ["black hat", "traditional hat", "religious headwear", "Orthodox hat"],
-            "clothing": ["traditional clothing", "religious attire", "formal wear", "dark clothing"]
+        self.setting_environments = {
+            "indoor": ["indoor", "inside", "interior", "room", "office", "home", "building"],
+            "formal": ["formal setting", "office", "meeting room", "conference", "official"],
+            "religious": ["synagogue", "temple", "religious", "ceremonial", "sacred"],
+            "studio": ["studio", "backdrop", "professional", "photography studio"],
+            "casual": ["casual", "relaxed", "informal", "comfortable"]
         }
         
-        self.settings_detailed = {
-            "indoor": ["indoor setting", "interior space", "indoor environment"],
-            "outdoor": ["outdoor setting", "natural environment", "exterior location"],
-            "studio": ["studio setting", "controlled environment", "professional backdrop"]
+        self.lighting_types = {
+            "natural": ["natural light", "window light", "daylight", "sunlight"],
+            "artificial": ["artificial light", "lamp", "electric", "indoor lighting"],
+            "dramatic": ["dramatic", "contrast", "shadow", "chiaroscuro", "moody"],
+            "soft": ["soft", "gentle", "diffused", "even", "flattering"],
+            "harsh": ["harsh", "direct", "strong", "bright", "intense"]
         }
         
-        self.lighting_advanced = {
-            "portrait": ["dramatic portrait lighting", "studio portrait lighting", "professional portrait setup"],
-            "natural": ["natural lighting", "window light", "ambient illumination"],
-            "dramatic": ["dramatic lighting", "high contrast lighting", "chiaroscuro lighting"]
+        self.composition_styles = {
+            "portrait": ["portrait", "headshot", "face", "facial", "close-up", "bust"],
+            "seated": ["sitting", "seated", "chair", "sitting down"],
+            "standing": ["standing", "upright", "vertical"],
+            "three_quarter": ["three quarter", "three-quarter", "angled", "turned"]
         }
         
-        self.technical_professional = {
-            "portrait_lens": ["85mm lens", "135mm lens", "medium telephoto"],
-            "standard_lens": ["50mm lens", "35mm lens", "standard focal length"],
-            "aperture": ["f/1.4 aperture", "f/2.8 aperture", "f/4 aperture"],
-            "camera": ["Shot on Phase One XF", "Shot on Hasselblad", "Shot on Canon EOS R5"]
+        self.quality_adjectives = {
+            "age_based": {
+                "elderly": ["distinguished", "dignified", "venerable", "wise", "weathered", "experienced"],
+                "middle": ["professional", "mature", "confident", "established"],
+                "young": ["youthful", "fresh", "vibrant", "energetic"]
+            },
+            "cultural": ["traditional", "Orthodox", "religious", "ceremonial", "devout"],
+            "general": ["elegant", "refined", "sophisticated", "classic", "timeless"]
         }
     
-    def analyze_clip_deeply(self, clip_result):
-        """Extract detailed information from CLIP analysis"""
-        clip_lower = clip_result.lower()
+    def extract_maximum_info(self, clip_fast, clip_classic, clip_best):
+        """Combine all three CLIP analyses for maximum information extraction"""
+        
+        # Combine all analyses
+        combined_text = f"{clip_fast} {clip_classic} {clip_best}".lower()
+        
         analysis = {
-            "subjects": [],
             "age": None,
-            "features": [],
-            "clothing": [],
+            "age_confidence": 0,
+            "gender": None,
+            "facial_features": [],
+            "hair_description": [],
+            "clothing_items": [],
+            "cultural_religious": [],
             "setting": None,
+            "lighting": None,
+            "composition": None,
             "mood": None,
-            "composition": None
+            "technical_suggestions": {}
         }
         
-        # Subject and age detection
-        if any(word in clip_lower for word in ["man", "person", "male"]):
-            if any(word in clip_lower for word in ["old", "elderly", "aged", "gray", "grey", "silver"]):
-                analysis["subjects"].append("elderly man")
-                analysis["age"] = "elderly"
-            elif any(word in clip_lower for word in ["young", "youth", "boy"]):
-                analysis["subjects"].append("young man")  
-                analysis["age"] = "young"
+        # DEEP AGE DETECTION
+        age_scores = {"elderly": 0, "middle": 0, "young": 0}
+        for age_type, keywords in self.age_keywords.items():
+            for keyword in keywords:
+                if keyword in combined_text:
+                    age_scores[age_type] += 1
+        
+        if max(age_scores.values()) > 0:
+            analysis["age"] = max(age_scores, key=age_scores.get)
+            analysis["age_confidence"] = age_scores[analysis["age"]]
+        
+        # GENDER DETECTION
+        if any(word in combined_text for word in ["man", "male", "gentleman", "guy", "he", "his"]):
+            analysis["gender"] = "man"
+        elif any(word in combined_text for word in ["woman", "female", "lady", "she", "her"]):
+            analysis["gender"] = "woman"
+        
+        # COMPREHENSIVE FACIAL FEATURES
+        if any(word in combined_text for word in self.facial_features["beard_full"]):
+            if any(word in combined_text for word in self.facial_features["beard_color"]):
+                analysis["facial_features"].append("silver beard")
             else:
-                analysis["subjects"].append("man")
-                analysis["age"] = "middle"
+                analysis["facial_features"].append("full beard")
         
-        if any(word in clip_lower for word in ["woman", "female", "lady"]):
-            if any(word in clip_lower for word in ["old", "elderly", "aged"]):
-                analysis["subjects"].append("elderly woman")
-                analysis["age"] = "elderly"
-            else:
-                analysis["subjects"].append("woman")
+        if any(word in combined_text for word in self.facial_features["glasses"]):
+            analysis["facial_features"].append("wire-frame glasses")
         
-        # Facial features detection
-        if any(word in clip_lower for word in ["beard", "facial hair", "mustache"]):
-            if any(word in clip_lower for word in ["gray", "grey", "silver", "white"]):
-                analysis["features"].append("silver beard")
-            else:
-                analysis["features"].append("beard")
+        if any(word in combined_text for word in self.facial_features["wrinkles"]):
+            analysis["facial_features"].append("weathered features")
         
-        if any(word in clip_lower for word in ["glasses", "spectacles", "eyeglasses"]):
-            analysis["features"].append("glasses")
+        # HAIR ANALYSIS
+        hair_colors = [color for color in self.hair_descriptors["color"] if color in combined_text]
+        if hair_colors:
+            analysis["hair_description"].extend(hair_colors)
         
-        # Clothing and accessories
-        if any(word in clip_lower for word in ["hat", "cap", "headwear"]):
-            analysis["clothing"].append("hat")
+        # CULTURAL/RELIGIOUS DETECTION
+        if any(word in combined_text for word in self.religious_cultural["jewish"]):
+            analysis["cultural_religious"].append("Orthodox Jewish")
+        
+        if any(word in combined_text for word in self.religious_cultural["hat_types"]):
+            analysis["clothing_items"].append("traditional black hat")
+        
+        if any(word in combined_text for word in self.religious_cultural["clothing"]):
+            analysis["clothing_items"].append("formal religious attire")
+        
+        # ENHANCED SETTING DETECTION
+        setting_scores = {}
+        for setting_type, keywords in self.setting_environments.items():
+            score = sum(1 for keyword in keywords if keyword in combined_text)
+            if score > 0:
+                setting_scores[setting_type] = score
+        
+        if setting_scores:
+            analysis["setting"] = max(setting_scores, key=setting_scores.get)
+        
+        # LIGHTING ANALYSIS
+        lighting_detected = []
+        for light_type, keywords in self.lighting_types.items():
+            if any(keyword in combined_text for keyword in keywords):
+                lighting_detected.append(light_type)
+        
+        if lighting_detected:
+            analysis["lighting"] = lighting_detected[0]  # Take first/strongest match
+        
+        # COMPOSITION DETECTION
+        for comp_type, keywords in self.composition_styles.items():
+            if any(keyword in combined_text for keyword in keywords):
+                analysis["composition"] = comp_type
+                break
+        
+        # TECHNICAL SUGGESTIONS BASED ON ANALYSIS
+        if analysis["composition"] == "portrait":
+            analysis["technical_suggestions"] = {
+                "lens": "85mm lens",
+                "aperture": "f/2.8 aperture",
+                "camera": "Shot on Phase One XF"
+            }
+        elif analysis["composition"] == "seated":
+            analysis["technical_suggestions"] = {
+                "lens": "85mm lens", 
+                "aperture": "f/4 aperture",
+                "camera": "Shot on Phase One"
+            }
+        else:
+            analysis["technical_suggestions"] = {
+                "lens": "50mm lens",
+                "aperture": "f/2.8 aperture", 
+                "camera": "Shot on Phase One"
+            }
         
-        if any(word in clip_lower for word in ["suit", "formal", "dress", "shirt"]):
-            analysis["clothing"].append("formal wear")
-            
-        # Setting detection  
-        if any(word in clip_lower for word in ["indoor", "inside", "interior", "room"]):
-            analysis["setting"] = "indoor"
-        elif any(word in clip_lower for word in ["outdoor", "outside", "landscape", "street"]):
-            analysis["setting"] = "outdoor"
-        elif any(word in clip_lower for word in ["studio", "backdrop"]):
-            analysis["setting"] = "studio"
-        
-        # Mood and composition
-        if any(word in clip_lower for word in ["portrait", "headshot", "face", "close-up"]):
-            analysis["composition"] = "portrait"
-        elif any(word in clip_lower for word in ["sitting", "seated", "chair"]):
-            analysis["composition"] = "seated"
-        elif any(word in clip_lower for word in ["standing", "upright"]):
-            analysis["composition"] = "standing"
-            
         return analysis
     
-    def build_flux_prompt(self, analysis, clip_base):
-        """Build optimized Flux prompt using deep analysis"""
+    def build_maximum_flux_prompt(self, analysis, original_clips):
+        """Build the most detailed Flux prompt possible"""
         components = []
         
-        # 1. Article (intelligent selection)
-        if analysis["subjects"]:
-            subject = analysis["subjects"][0]
-            article = "An" if subject[0] in 'aeiou' else "A"
+        # 1. INTELLIGENT ARTICLE SELECTION
+        if analysis["cultural_religious"] and analysis["age"]:
+            # "An elderly Orthodox Jewish man"
+            article = "An" if analysis["age"] == "elderly" else "A"
+        elif analysis["gender"]:
+            article = "A"
         else:
             article = "A"
         components.append(article)
         
-        # 2. Descriptive adjectives (context-aware)
+        # 2. CONTEXT-AWARE ADJECTIVES (max 2-3 per Flux rules)
         adjectives = []
-        if analysis["age"] == "elderly":
-            adjectives.extend(["distinguished", "weathered"])
-        elif analysis["age"] == "young":
-            adjectives.extend(["young", "fresh-faced"])
-        else:
-            adjectives.extend(["professional", "elegant"])
         
-        # Add up to 2-3 adjectives as per Flux rules
+        if analysis["age"] and analysis["age"] in self.quality_adjectives["age_based"]:
+            adjectives.extend(self.quality_adjectives["age_based"][analysis["age"]][:2])
+        
+        if analysis["cultural_religious"]:
+            adjectives.extend(self.quality_adjectives["cultural"][:1])
+        
+        if not adjectives:
+            adjectives = self.quality_adjectives["general"][:2]
+        
+        # Limit to 2-3 adjectives as per Flux rules
         components.extend(adjectives[:2])
         
-        # 3. Main subject (enhanced with details)
-        if analysis["subjects"]:
-            main_subject = analysis["subjects"][0]
-            # Add religious/cultural context if detected
-            if "hat" in analysis["clothing"] and "beard" in [f.split()[0] for f in analysis["features"]]:
-                main_subject = "Orthodox Jewish " + main_subject
+        # 3. ENHANCED SUBJECT DESCRIPTION
+        subject_parts = []
+        
+        if analysis["cultural_religious"]:
+            subject_parts.extend(analysis["cultural_religious"])
+        
+        if analysis["age"] and analysis["age"] != "middle":
+            subject_parts.append(analysis["age"])
+        
+        if analysis["gender"]:
+            subject_parts.append(analysis["gender"])
         else:
-            main_subject = "subject"
-        components.append(main_subject)
+            subject_parts.append("person")
         
-        # 4. Features integration (intelligent placement)
-        feature_descriptions = []
-        if "glasses" in analysis["features"]:
-            feature_descriptions.append("with distinctive wire-frame glasses")
-        if any("beard" in f for f in analysis["features"]):
-            if "silver beard" in analysis["features"]:
-                feature_descriptions.append("with a distinguished silver beard")
-            else:
-                feature_descriptions.append("with a full beard")
+        main_subject = " ".join(subject_parts)
+        components.append(main_subject)
         
-        if feature_descriptions:
-            components.extend(feature_descriptions)
+        # 4. DETAILED FACIAL FEATURES
+        if analysis["facial_features"]:
+            feature_desc = "with " + " and ".join(analysis["facial_features"])
+            components.append(feature_desc)
+        
+        # 5. CLOTHING AND ACCESSORIES
+        if analysis["clothing_items"]:
+            clothing_desc = "wearing " + " and ".join(analysis["clothing_items"])
+            components.append(clothing_desc)
+        
+        # 6. ACTION/POSE (based on composition)
+        action_map = {
+            "seated": "seated in contemplative pose",
+            "standing": "standing with dignified presence", 
+            "portrait": "captured in intimate portrait style",
+            "three_quarter": "positioned in three-quarter view"
+        }
         
-        # 5. Clothing and accessories
-        clothing_desc = []
-        if "hat" in analysis["clothing"]:
-            clothing_desc.append("wearing a traditional black hat")
-        if "formal wear" in analysis["clothing"]:
-            clothing_desc.append("in formal attire")
-            
-        if clothing_desc:
-            components.extend(clothing_desc)
-        
-        # 6. Verb/Action (based on composition analysis)
-        if analysis["composition"] == "seated":
-            action = "seated contemplatively"
-        elif analysis["composition"] == "standing":
-            action = "standing with dignity"
+        if analysis["composition"]:
+            action = action_map.get(analysis["composition"], "positioned thoughtfully")
         else:
-            action = "positioned thoughtfully"
+            action = "positioned with natural composure"
         components.append(action)
         
-        # 7. Context/Location (enhanced setting)
-        setting_map = {
-            "indoor": "in an intimate indoor setting",
-            "outdoor": "in a natural outdoor environment",
-            "studio": "in a professional studio environment"
+        # 7. ENHANCED ENVIRONMENTAL CONTEXT
+        setting_descriptions = {
+            "indoor": "in a warmly lit indoor environment",
+            "formal": "in a professional formal setting",
+            "religious": "in a traditional religious space",
+            "studio": "in a controlled studio environment",
+            "casual": "in a comfortable informal setting"
         }
         
         if analysis["setting"]:
-            context = setting_map.get(analysis["setting"], "in a carefully composed environment")
+            context = setting_descriptions.get(analysis["setting"], "in a thoughtfully composed environment")
         else:
-            context = "in a thoughtfully arranged scene"
+            context = "within a carefully arranged scene"
         components.append(context)
         
-        # 8. Environmental details (lighting-aware)
-        if analysis["composition"] == "portrait":
-            env_detail = "with dramatic portrait lighting that emphasizes facial features and texture"
+        # 8. SOPHISTICATED LIGHTING DESCRIPTION
+        lighting_descriptions = {
+            "natural": "bathed in gentle natural lighting that enhances facial texture and depth",
+            "dramatic": "illuminated by dramatic lighting that creates compelling shadows and highlights",
+            "soft": "softly lit to emphasize character and warmth",
+            "artificial": "under controlled artificial lighting for optimal detail capture"
+        }
+        
+        if analysis["lighting"]:
+            lighting_desc = lighting_descriptions.get(analysis["lighting"], "with professional lighting that emphasizes facial features and texture")
         else:
-            env_detail = "captured with sophisticated atmospheric lighting"
-        components.append(env_detail)
+            lighting_desc = "captured with sophisticated portrait lighting that brings out intricate facial details"
         
-        # 9. Technical specifications (composition-appropriate)
-        if analysis["composition"] == "portrait":
-            tech_spec = "Shot on Phase One XF, 85mm lens, f/2.8 aperture"
+        components.append(lighting_desc)
+        
+        # 9. TECHNICAL SPECIFICATIONS
+        tech_parts = []
+        if analysis["technical_suggestions"]:
+            tech_parts.append(analysis["technical_suggestions"]["camera"])
+            tech_parts.append(analysis["technical_suggestions"]["lens"])
+            tech_parts.append(analysis["technical_suggestions"]["aperture"])
         else:
-            tech_spec = "Shot on Phase One, 50mm lens, f/4 aperture"
-        components.append(tech_spec)
+            tech_parts = ["Shot on Phase One", "85mm lens", "f/2.8 aperture"]
         
-        # 10. Quality marker (always professional)
-        components.append("professional photography")
+        components.append(", ".join(tech_parts))
         
-        # Join with proper punctuation
+        # 10. QUALITY MARKER
+        components.append("professional portrait photography")
+        
+        # FINAL ASSEMBLY AND OPTIMIZATION
         prompt = ", ".join(components)
         
-        # Clean up and optimize
+        # Clean up the prompt
         prompt = re.sub(r'\s+', ' ', prompt)  # Remove extra spaces
-        prompt = prompt.replace(", ,", ",")   # Remove double commas
+        prompt = re.sub(r',\s*,', ',', prompt)  # Remove double commas
+        prompt = prompt.replace(" ,", ",")  # Fix spacing around commas
+        
+        # Ensure proper capitalization
+        prompt = prompt[0].upper() + prompt[1:] if prompt else ""
         
         return prompt
     
-    def calculate_intelligence_score(self, prompt, analysis):
-        """Calculate how well the prompt reflects intelligent analysis"""
+    def calculate_maximum_score(self, prompt, analysis):
+        """Calculate intelligence score based on depth of analysis"""
         score = 0
+        max_possible = 100
         
-        # Structure compliance (Flux rules 1-10)
+        # Structure compliance (10 points)
         if prompt.startswith(("A", "An")):
             score += 10
-            
-        # Feature recognition accuracy
-        if len(analysis["features"]) > 0:
-            score += 15
-            
-        # Context understanding
-        if analysis["setting"]:
-            score += 15
-            
-        # Subject detail depth
-        if len(analysis["subjects"]) > 0:
+        
+        # Feature detection depth (20 points)
+        feature_score = len(analysis["facial_features"]) * 5
+        score += min(feature_score, 20)
+        
+        # Cultural/contextual awareness (20 points)
+        if analysis["cultural_religious"]:
             score += 15
-            
-        # Technical specs presence
-        if "Phase One" in prompt and "lens" in prompt:
+        if analysis["age"]:
+            score += 5
+        
+        # Technical appropriateness (15 points)
+        if "85mm" in prompt and analysis["composition"] in ["portrait", "seated"]:
             score += 15
-            
-        # Lighting specification
-        if "lighting" in prompt:
+        elif "50mm" in prompt:
             score += 10
-            
-        # Composition awareness
-        if analysis["composition"]:
+        
+        # Lighting sophistication (15 points)
+        if "lighting" in prompt and len(prompt.split("lighting")[1].split(",")[0]) > 10:
+            score += 15
+        
+        # Setting context (10 points)
+        if analysis["setting"]:
             score += 10
-            
-        # Forbidden elements check
+        
+        # Forbidden elements check (10 points)
         if not any(forbidden in prompt for forbidden in self.forbidden_elements):
             score += 10
-            
-        return min(score, 100)
+        
+        return min(score, max_possible)
 
-class FluxPromptOptimizer:
+class MaximumFluxOptimizer:
     def __init__(self):
         self.interrogator = None
-        self.analyzer = DeepFluxAnalyzer()
+        self.analyzer = MaximumFluxAnalyzer()
         self.usage_count = 0
         self.device = DEVICE
         self.is_initialized = False
@@ -337,7 +432,7 @@ class FluxPromptOptimizer:
         return image
     
     @spaces.GPU
-    def generate_optimized_prompt(self, image):
+    def generate_maximum_prompt(self, image):
         try:
             if not self.is_initialized:
                 if not self.initialize_model():
@@ -354,17 +449,23 @@ class FluxPromptOptimizer:
             
             start_time = datetime.now()
             
-            # Get comprehensive CLIP analysis
-            clip_result = self.interrogator.interrogate(image)
+            # TRIPLE CLIP ANALYSIS FOR MAXIMUM INFORMATION
+            logger.info("Starting MAXIMUM analysis - Triple CLIP interrogation")
+            
+            clip_fast = self.interrogator.interrogate_fast(image)
+            clip_classic = self.interrogator.interrogate_classic(image) 
+            clip_best = self.interrogator.interrogate(image)
+            
+            logger.info(f"CLIP Results:\nFast: {clip_fast}\nClassic: {clip_classic}\nBest: {clip_best}")
             
-            # Deep analysis of the CLIP result
-            deep_analysis = self.analyzer.analyze_clip_deeply(clip_result)
+            # MAXIMUM DEPTH ANALYSIS
+            deep_analysis = self.analyzer.extract_maximum_info(clip_fast, clip_classic, clip_best)
             
-            # Build optimized Flux prompt
-            optimized_prompt = self.analyzer.build_flux_prompt(deep_analysis, clip_result)
+            # BUILD MAXIMUM QUALITY FLUX PROMPT
+            optimized_prompt = self.analyzer.build_maximum_flux_prompt(deep_analysis, [clip_fast, clip_classic, clip_best])
             
-            # Calculate intelligence score
-            score = self.analyzer.calculate_intelligence_score(optimized_prompt, deep_analysis)
+            # CALCULATE INTELLIGENCE SCORE
+            score = self.analyzer.calculate_maximum_score(optimized_prompt, deep_analysis)
             
             end_time = datetime.now()
             duration = (end_time - start_time).total_seconds()
@@ -375,67 +476,93 @@ class FluxPromptOptimizer:
             else:
                 torch.cuda.empty_cache()
             
-            # Generate detailed analysis info
+            # COMPREHENSIVE ANALYSIS REPORT
             gpu_status = "⚡ ZeroGPU" if torch.cuda.is_available() else "💻 CPU"
             
-            features_detected = ", ".join(deep_analysis["features"]) if deep_analysis["features"] else "None"
-            subjects_detected = ", ".join(deep_analysis["subjects"]) if deep_analysis["subjects"] else "Generic"
+            # Format detected elements
+            features = ", ".join(deep_analysis["facial_features"]) if deep_analysis["facial_features"] else "None detected"
+            cultural = ", ".join(deep_analysis["cultural_religious"]) if deep_analysis["cultural_religious"] else "None detected"
+            clothing = ", ".join(deep_analysis["clothing_items"]) if deep_analysis["clothing_items"] else "None detected"
             
-            analysis_info = f"""**Deep Analysis Complete**
+            analysis_info = f"""**MAXIMUM ANALYSIS COMPLETE**
 
-**Processing:** {gpu_status} • {duration:.1f}s  
+**Processing:** {gpu_status} • {duration:.1f}s • Triple CLIP interrogation  
 **Intelligence Score:** {score}/100  
+**Analysis Confidence:** {deep_analysis.get("age_confidence", 0)} age indicators detected  
 **Generation:** #{self.usage_count}  
 
-**Detected Elements:**
-• **Subjects:** {subjects_detected}
-• **Features:** {features_detected}  
-• **Setting:** {deep_analysis["setting"] or "Unspecified"}
-• **Composition:** {deep_analysis["composition"] or "Standard"}
+**DEEP DETECTION RESULTS:**
+• **Age Category:** {deep_analysis.get("age", "Unspecified").title()}
+• **Cultural Context:** {cultural}  
+• **Facial Features:** {features}
+• **Clothing/Accessories:** {clothing}
+• **Setting:** {deep_analysis.get("setting", "Standard").title()}
+• **Composition:** {deep_analysis.get("composition", "Standard").title()}
+• **Lighting:** {deep_analysis.get("lighting", "Standard").title()}
 
-**CLIP Base:** {clip_result[:80]}...  
-**Flux Enhancement:** Applied deep analysis with Pariente AI rules"""
+**CLIP ANALYSIS SOURCES:**
+• **Fast:** {clip_fast[:60]}...
+• **Classic:** {clip_classic[:60]}...  
+• **Best:** {clip_best[:60]}...
+
+**FLUX OPTIMIZATION:** Applied maximum depth analysis with Pariente AI research rules"""
             
             return optimized_prompt, analysis_info, score
             
         except Exception as e:
-            logger.error(f"Generation error: {e}")
+            logger.error(f"Maximum generation error: {e}")
             return f"❌ Error: {str(e)}", "Please try with a different image.", 0
 
-optimizer = FluxPromptOptimizer()
+optimizer = MaximumFluxOptimizer()
 
-def process_image_wrapper(image):
-    """Simplified wrapper - no unnecessary options"""
+def process_maximum_analysis(image):
+    """Maximum analysis wrapper"""
     try:
-        prompt, info, score = optimizer.generate_optimized_prompt(image)
-        
-        # Create score HTML
-        color = "#22c55e" if score >= 80 else "#f59e0b" if score >= 60 else "#ef4444"
+        prompt, info, score = optimizer.generate_maximum_prompt(image)
+        
+        # Enhanced score display
+        if score >= 90:
+            color = "#10b981"
+            grade = "EXCELLENT"
+        elif score >= 80:
+            color = "#22c55e" 
+            grade = "VERY GOOD"
+        elif score >= 70:
+            color = "#f59e0b"
+            grade = "GOOD"
+        elif score >= 60:
+            color = "#f97316"
+            grade = "FAIR"
+        else:
+            color = "#ef4444"
+            grade = "NEEDS WORK"
+            
         score_html = f'''
-        <div style="text-align: center; padding: 1rem; background: linear-gradient(135deg, #f0fdf4 0%, #dcfce7 100%); border: 2px solid {color}; border-radius: 12px; margin: 1rem 0;">
-            <div style="font-size: 2rem; font-weight: 700; color: {color}; margin: 0;">{score}</div>
-            <div style="font-size: 0.875rem; color: #15803d; margin: 0; text-transform: uppercase; letter-spacing: 0.05em;">Intelligence Score</div>
+        <div style="text-align: center; padding: 1.5rem; background: linear-gradient(135deg, #f0fdf4 0%, #dcfce7 100%); border: 2px solid {color}; border-radius: 12px; margin: 1rem 0; box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1);">
+            <div style="font-size: 2.5rem; font-weight: 700; color: {color}; margin: 0;">{score}</div>
+            <div style="font-size: 1rem; color: #15803d; margin: 0; text-transform: uppercase; letter-spacing: 0.05em; font-weight: 600;">{grade}</div>
+            <div style="font-size: 0.875rem; color: #15803d; margin: 0; text-transform: uppercase; letter-spacing: 0.05em;">Maximum Intelligence Score</div>
         </div>
         '''
         
         return prompt, info, score_html
         
     except Exception as e:
-        logger.error(f"Wrapper error: {e}")
+        logger.error(f"Maximum wrapper error: {e}")
         return "❌ Processing failed", f"Error: {str(e)}", '<div style="text-align: center; color: red;">Error</div>'
 
 def clear_outputs():
     gc.collect()
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
-    return "", "", '<div style="text-align: center; padding: 1rem;"><div style="font-size: 2rem; color: #ccc;">--</div><div style="font-size: 0.875rem; color: #999;">Intelligence Score</div></div>'
+    return "", "", '<div style="text-align: center; padding: 1rem;"><div style="font-size: 2rem; color: #ccc;">--</div><div style="font-size: 0.875rem; color: #999;">Maximum Intelligence Score</div></div>'
 
 def create_interface():
     css = """
-    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap');
+    @import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&display=swap');
     
     .gradio-container {
-        max-width: 1200px !important;
+        max-width: 1400px !important;
         margin: 0 auto !important;
         font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif !important;
         background: linear-gradient(135deg, #f8fafc 0%, #f1f5f9 100%) !important;
@@ -444,117 +571,123 @@ def create_interface():
     .main-header {
         text-align: center;
         padding: 2rem 0 3rem 0;
-        background: linear-gradient(135deg, #1e293b 0%, #334155 100%);
+        background: linear-gradient(135deg, #0f172a 0%, #1e293b 50%, #334155 100%);
         color: white;
         margin: -2rem -2rem 2rem -2rem;
         border-radius: 0 0 24px 24px;
+        box-shadow: 0 10px 25px -5px rgba(0, 0, 0, 0.1);
     }
     
     .main-title {
-        font-size: 2.5rem !important;
-        font-weight: 700 !important;
+        font-size: 3rem !important;
+        font-weight: 800 !important;
         margin: 0 0 0.5rem 0 !important;
         letter-spacing: -0.025em !important;
-        background: linear-gradient(135deg, #60a5fa 0%, #3b82f6 100%);
+        background: linear-gradient(135deg, #60a5fa 0%, #3b82f6 50%, #2563eb 100%);
         -webkit-background-clip: text;
         -webkit-text-fill-color: transparent;
         background-clip: text;
     }
     
     .subtitle {
-        font-size: 1.125rem !important;
+        font-size: 1.25rem !important;
         font-weight: 400 !important;
-        opacity: 0.8 !important;
+        opacity: 0.9 !important;
         margin: 0 !important;
     }
     
     .prompt-output {
         font-family: 'SF Mono', 'Monaco', 'Inconsolata', 'Roboto Mono', monospace !important;
         font-size: 14px !important;
-        line-height: 1.6 !important;
+        line-height: 1.7 !important;
         background: linear-gradient(135deg, #ffffff 0%, #f8fafc 100%) !important;
         border: 1px solid #e2e8f0 !important;
-        border-radius: 12px !important;
-        padding: 1.5rem !important;
-        box-shadow: 0 4px 6px -1px rgba(0, 0, 0, 0.1) !important;
+        border-radius: 16px !important;
+        padding: 2rem !important;
+        box-shadow: 0 8px 25px -5px rgba(0, 0, 0, 0.1) !important;
     }
     """
     
     with gr.Blocks(
         theme=gr.themes.Soft(),
-        title="Flux Prompt Optimizer",
+        title="Maximum Flux Prompt Optimizer",
         css=css
     ) as interface:
         
         gr.HTML("""
         <div class="main-header">
-            <div class="main-title">⚡ Flux Prompt Optimizer</div>
-            <div class="subtitle">Deep AI analysis • Intelligent prompt generation • Research-based optimization</div>
+            <div class="main-title">🧠 Maximum Flux Optimizer</div>
+            <div class="subtitle">Triple CLIP Analysis • Maximum Intelligence • Zero Configuration</div>
         </div>
         """)
         
         with gr.Row():
             with gr.Column(scale=1):
-                gr.Markdown("## 📷 Image Analysis")
+                gr.Markdown("## 🔬 Maximum Analysis")
                 
                 image_input = gr.Image(
-                    label="Upload your image",
+                    label="Upload your image for maximum analysis",
                     type="pil",
-                    height=400
+                    height=450
                 )
                 
-                optimize_btn = gr.Button(
-                    "🧠 Analyze & Optimize",
+                analyze_btn = gr.Button(
+                    "🚀 MAXIMUM ANALYSIS",
                     variant="primary",
                     size="lg"
                 )
                 
                 gr.Markdown("""
-                ### Deep Analysis Engine
+                ### Maximum Intelligence Engine
                 
-                This system performs comprehensive image analysis:
+                **Triple CLIP Interrogation:**
+                • Fast analysis for broad context
+                • Classic analysis for detailed features  
+                • Best analysis for maximum depth
                 
-                • **Subject Recognition** - Identifies people, objects, context
-                • **Feature Detection** - Facial features, clothing, accessories  
-                • **Composition Analysis** - Lighting, setting, mood
-                • **Flux Optimization** - Applies research-validated rules
+                **Deep Feature Extraction:**
+                • Age, gender, cultural context
+                • Facial features, expressions, accessories
+                • Clothing, religious/cultural indicators
+                • Environmental setting and lighting
+                • Composition and technical optimization
                 
-                No options needed - the AI decides what's optimal.
+                **No configuration needed** - Maximum intelligence applied automatically.
                 """)
             
             with gr.Column(scale=1):
-                gr.Markdown("## 🎯 Optimized Result")
+                gr.Markdown("## ⚡ Maximum Result")
                 
                 prompt_output = gr.Textbox(
-                    label="Flux-Optimized Prompt",
-                    placeholder="Upload an image to see the intelligent analysis and optimization...",
-                    lines=8,
-                    max_lines=12,
+                    label="Maximum Optimized Flux Prompt",
+                    placeholder="Upload an image to see the maximum intelligence analysis...",
+                    lines=10,
+                    max_lines=15,
                     elem_classes=["prompt-output"],
                     show_copy_button=True
                 )
                 
                 score_output = gr.HTML(
-                    value='<div style="text-align: center; padding: 1rem;"><div style="font-size: 2rem; color: #ccc;">--</div><div style="font-size: 0.875rem; color: #999;">Intelligence Score</div></div>'
+                    value='<div style="text-align: center; padding: 1rem;"><div style="font-size: 2rem; color: #ccc;">--</div><div style="font-size: 0.875rem; color: #999;">Maximum Intelligence Score</div></div>'
                 )
                 
                 info_output = gr.Markdown(value="")
                 
-                clear_btn = gr.Button("🗑️ Clear", size="sm")
+                clear_btn = gr.Button("🗑️ Clear Analysis", size="sm")
         
         gr.Markdown("""
         ---
-        ### 🔬 Pariente AI Research Foundation
+        ### 🔬 Maximum Research Foundation
         
-        This optimizer implements deep computer vision analysis combined with validated Flux prompt engineering rules. 
-        The system intelligently recognizes image content and applies structured optimization without requiring user configuration.
+        This system represents the absolute maximum in image analysis and Flux prompt optimization. Using triple CLIP interrogation 
+        and deep feature extraction, it identifies every possible detail and applies research-validated Flux rules with maximum intelligence.
         
-        **Research-based • Intelligence-driven • Zero configuration needed**
+        **Pariente AI Research Laboratory** • Maximum Intelligence • Research-Driven • Zero Compromise
         """)
         
-        # Simple event handlers
-        optimize_btn.click(
-            fn=process_image_wrapper,
+        # Maximum event handlers
+        analyze_btn.click(
+            fn=process_maximum_analysis,
             inputs=[image_input],
             outputs=[prompt_output, info_output, score_output]
         )
@@ -567,7 +700,7 @@ def create_interface():
     return interface
 
 if __name__ == "__main__":
-    logger.info("🚀 Starting Deep Flux Prompt Optimizer")
+    logger.info("🚀 Starting MAXIMUM Flux Prompt Optimizer")
     interface = create_interface()
     interface.launch(
         server_name="0.0.0.0",