Update app.py

app.py

@@ -6,13 +6,13 @@ import matplotlib.pyplot as plt
 from transformers import pipeline
 import gradio as gr
 from sklearn.cluster import KMeans
+from colorsys import rgb_to_hsv
 
 # Emotion detection pipeline for text (if any text is included in assets)
 emotion_classifier = pipeline("text-classification", model="j-hartmann/emotion-english-distilroberta-base", return_all_scores=True)
 
 # Function to analyze colors in an image
 def analyze_colors(image):
-    print(f"Image type: {type(image)}, Image mode: {image.mode}")  # Debugging line
     try:
         # Ensure the image is in RGB format
         if image.mode != "RGB":
@@ -24,19 +24,9 @@ def analyze_colors(image):
         # Convert to numpy array
         img_array = np.array(image)
 
-        # Check if the image has a valid shape
-        if img_array.ndim != 3 or img_array.shape[2] != 3:
-            raise ValueError("Invalid image array shape: Expected a 3D array with 3 channels.")
-
         # Reshape image to be a list of pixels
         pixels = img_array.reshape((-1, 3))
 
-        print(f"Image shape: {img_array.shape}")  # Debugging line
-        print(f"Number of pixels: {len(pixels)}")  # Debugging line
-
-        if len(pixels) < 5:
-            return "Image has too few pixels for analysis"
-
         kmeans = KMeans(n_clusters=5, random_state=0)
         kmeans.fit(pixels)
         dominant_colors = kmeans.cluster_centers_
@@ -50,30 +40,47 @@ def analyze_colors(image):
         return dominant_colors
 
     except Exception as e:
-        print(f"Error in analyze_colors: {e}")  # Capture the error
+        print(f"Error in analyze_colors: {e}")
         return None
 
 
-# Function to detect emotions from colors (simplified emotion-color mapping)
+# Function to analyze emotions based on color (hue, brightness, saturation) and stress with weights
 def color_emotion_analysis(dominant_colors):
     try:
         emotions = []
         stress_levels = []
         
+        # Weight coefficients for each factor
+        brightness_weight = 0.5
+        hue_weight = 0.3
+        saturation_weight = 0.2
+
         for color in dominant_colors:
-            brightness = np.mean(color)
+            # Normalize RGB values to 0-1 range
+            r, g, b = color / 255.0
+
+            # Convert RGB to HSV
+            h, s, v = rgb_to_hsv(r, g, b)  # Hue, Saturation, Value (brightness)
 
-            # Simple logic for emotion and stress based on brightness
-            if brightness < 85:
+            # Calculate weighted emotion and stress levels
+            weighted_brightness = v * brightness_weight
+            weighted_hue = h * hue_weight
+            weighted_saturation = s * saturation_weight
+
+            # Combine weighted factors
+            score = weighted_brightness + weighted_hue + weighted_saturation
+
+            # Analyze emotion and stress based on combined score
+            if score < 0.3:  # Lower combined score, less rigid "high stress"
                 emotions.append("Sadness")
-                stress_levels.append("High Stress")
-            elif 85 <= brightness < 120:
+                stress_levels.append("Moderate-High Stress")
+            elif 0.3 <= score < 0.5:
                 emotions.append("Neutral")
                 stress_levels.append("Moderate Stress")
-            elif 120 <= brightness < 170:
+            elif 0.5 <= score < 0.7:
                 emotions.append("Okay")
                 stress_levels.append("Low Stress")
-            elif 170 <= brightness < 200:
+            elif 0.7 <= score < 0.85:
                 emotions.append("Happiness")
                 stress_levels.append("Very Low Stress")
             else:
@@ -86,6 +93,7 @@ def color_emotion_analysis(dominant_colors):
         print(f"Error in color_emotion_analysis: {e}")
         return ["Error analyzing emotions"], ["Error analyzing stress levels"]
 
+
 # Function to analyze patterns and shapes using OpenCV
 def analyze_patterns(image):
     try:
@@ -97,12 +105,12 @@ def analyze_patterns(image):
         num_edges = np.sum(edges > 0)
 
         if num_edges > 10000:  # Arbitrary threshold for "chaos"
-            return "Chaotic patterns - possibly distress", "High Stress"
+            return "Chaotic patterns - possibly distress"
         else:
-            return "Orderly patterns - possibly calm", "Low Stress"
+            return "Orderly patterns - possibly calm"
     except Exception as e:
         print(f"Error in analyze_patterns: {e}")
-        return "Error analyzing patterns", "Error analyzing stress levels"
+        return "Error analyzing patterns"
 
 # Main function to process image and analyze emotional expression
 def analyze_emotion_from_image(image):
@@ -116,19 +124,12 @@ def analyze_emotion_from_image(image):
         if dominant_colors is None:
             return "Error analyzing colors"
         
-        color_emotions, color_stress_levels = color_emotion_analysis(dominant_colors)
+        color_emotions, stress_levels = color_emotion_analysis(dominant_colors)
 
         # Analyze patterns
-        pattern_analysis, pattern_stress_level = analyze_patterns(image)
-
-        # Combine color and pattern stress levels
-        overall_stress_level = pattern_stress_level if "High Stress" in color_stress_levels else "Moderate Stress"
-
-        return (f"Color-based emotions: {color_emotions}\n"
-                f"Color-based stress levels: {color_stress_levels}\n"
-                f"Pattern analysis: {pattern_analysis}\n"
-                f"Overall stress level: {overall_stress_level}")
+        pattern_analysis = analyze_patterns(image)
 
+        return f"Color-based emotions: {color_emotions}\nStress levels: {stress_levels}\nPattern analysis: {pattern_analysis}"
     except Exception as e:
         return f"Error processing image: {str(e)}"