Create cosmetics_matching.py

cosmetics_matching.py

@@ -0,0 +1,274 @@
+from fastapi import FastAPI, File, UploadFile, HTTPException, Depends
+import numpy as np
+import cv2
+from sklearn.cluster import KMeans
+import colorsys
+
+class SkinToneAnalyzer:
+    def __init__(self):
+        self.skin_tone_ranges = {
+            'fair': (0, 30),
+            'light': (30, 45), 
+            'medium': (45, 60),
+            'tan': (60, 75),
+            'deep': (75, 90),
+            'dark': (90, 100)
+        }
+        
+        self.undertone_rules = {
+            'warm': {'g/r_ratio': (0.4, 0.6), 'b/g_ratio': (0.5, 0.7)},
+            'cool': {'g/r_ratio': (0.6, 0.8), 'b/g_ratio': (0.7, 0.9)},
+            'neutral': {'g/r_ratio': (0.5, 0.7), 'b/g_ratio': (0.6, 0.8)},
+            'olive': {'g/r_ratio': (0.5, 0.7), 'b/g_ratio': (0.4, 0.6)}
+        }
+    
+    def analyze_skin_tone(self, image_bytes: bytes) -> dict:
+        """
+        Analyze skin tone from image
+        """
+        # Convert to OpenCV format
+        nparr = np.frombuffer(image_bytes, np.uint8)
+        img = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+        img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        
+        # Detect skin regions using face detection
+        face_cascade = cv2.CascadeClassifier(
+            cv2.data.haarcascades + 'haarcascade_frontalface_default.xml'
+        )
+        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        faces = face_cascade.detectMultiScale(gray, 1.1, 4)
+        
+        if len(faces) == 0:
+            return {"error": "No face detected"}
+        
+        # Extract skin samples from cheeks
+        skin_samples = []
+        for (x, y, w, h) in faces:
+            # Left cheek area
+            left_cheek = img_rgb[y + h//3:y + h//2, x + w//8:x + w//4]
+            # Right cheek area
+            right_cheek = img_rgb[y + h//3:y + h//2, x + 3*w//4:x + 7*w//8]
+            
+            skin_samples.extend(left_cheek.reshape(-1, 3))
+            skin_samples.extend(right_cheek.reshape(-1, 3))
+        
+        # Cluster to find dominant skin tone
+        kmeans = KMeans(n_clusters=3, random_state=42)
+        kmeans.fit(skin_samples)
+        
+        # Get the most representative cluster
+        dominant_color = kmeans.cluster_centers_[np.argmax(np.bincount(kmeans.labels_))]
+        r, g, b = dominant_color
+        
+        # Calculate melanin level
+        melanin_level = self._calculate_melanin(r, g, b)
+        
+        # Determine primary tone
+        primary_tone = self._get_primary_tone(melanin_level)
+        
+        # Determine undertone
+        undertone = self._get_undertone(r, g, b)
+        
+        # Calculate RGB values
+        rgb_values = {
+            'r': float(r),
+            'g': float(g),
+            'b': float(b),
+            'hex': f"{int(r):02x}{int(g):02x}{int(b):02x}"
+        }
+        
+        return {
+            'primary_tone': primary_tone,
+            'undertone': undertone,
+            'surface_tone': self._get_surface_tone(r, g, b),
+            'melanin_level': float(melanin_level),
+            'rgb_values': rgb_values,
+            'foundation_match': self._get_foundation_match(primary_tone, undertone),
+            'analyzed_at': datetime.utcnow().isoformat()
+        }
+    
+    def _calculate_melanin(self, r, g, b):
+        """
+        Calculate melanin level using ITA (Individual Typology Angle)
+        """
+        # Convert to LAB color space
+        rgb_normalized = np.array([[[r/255, g/255, b/255]]], dtype=np.float32)
+        lab = cv2.cvtColor(rgb_normalized, cv2.COLOR_RGB2LAB)
+        l, a, _ = lab[0][0]
+        
+        # ITA calculation
+        ita = np.arctan((l - 50) / a) * 180 / np.pi
+        
+        # Convert ITA to melanin level (0-100)
+        melanin = 100 - ((ita + 90) / 180 * 100)
+        return max(0, min(100, melanin))
+    
+    def _get_primary_tone(self, melanin):
+        """
+        Determine primary skin tone based on melanin level
+        """
+        for tone, (low, high) in self.skin_tone_ranges.items():
+            if low <= melanin <= high:
+                return tone
+        return 'medium'  # default
+    
+    def _get_undertone(self, r, g, b):
+        """
+        Determine undertone using color ratios
+        """
+        g_r_ratio = g / r if r > 0 else 0
+        b_g_ratio = b / g if g > 0 else 0
+        
+        for undertone, rules in self.undertone_rules.items():
+            g_ratio_min, g_ratio_max = rules['g/r_ratio']
+            b_ratio_min, b_ratio_max = rules['b/g_ratio']
+            
+            if (g_ratio_min <= g_r_ratio <= g_ratio_max and
+                b_ratio_min <= b_g_ratio <= b_ratio_max):
+                return undertone
+        
+        return 'neutral'  # default
+    
+    def _get_surface_tone(self, r, g, b):
+        """
+        Get surface complexion (may differ from undertone)
+        """
+        # Convert to HSV for surface analysis
+        h, s, v = colorsys.rgb_to_hsv(r/255, g/255, b/255)
+        
+        if v > 0.8:
+            return 'bright'
+        elif v < 0.3:
+            return 'deep'
+        else:
+            return 'natural'
+    
+    def _get_foundation_match(self, primary_tone, undertone):
+        """
+        Suggest foundation match based on skin analysis
+        """
+        return f"{primary_tone.capitalize()} with {undertone} undertone"
+
+class CosmeticMatcher:
+    def __init__(self):
+        self.product_database = load_cosmetics_database()
+    
+    def find_matches(self, skin_tone: dict, conditions: list) -> list:
+        """
+        Find cosmetic matches based on skin analysis
+        """
+        matches = []
+        
+        for product in self.product_database:
+            score = self._calculate_match_score(product, skin_tone, conditions)
+            
+            if score > 70:
+                matches.append({
+                    'product': product,
+                    'score': score,
+                    'reason': self._get_match_reason(product, score),
+                    'shades': self._find_best_shades(product, skin_tone)
+                })
+        
+        # Sort by score
+        matches.sort(key=lambda x: x['score'], reverse=True)
+        return matches[:20]  # Top 20 matches
+    
+    def _calculate_match_score(self, product, skin_tone, conditions):
+        """
+        Calculate how well a product matches the user
+        """
+        score = 50  # Base score
+        
+        # Undertone compatibility
+        if product.get('undertone') == skin_tone['undertone']:
+            score += 20
+        elif product.get('undertone') == 'neutral':
+            score += 10
+        else:
+            score -= 10
+        
+        # Skin tone range compatibility
+        if skin_tone['primary_tone'] in product.get('skin_tone_ranges', []):
+            score += 15
+        elif 'all' in product.get('skin_tone_ranges', []):
+            score += 10
+        
+        # Skin condition safety
+        for condition in conditions:
+            if self._is_safe_for_condition(product, condition):
+                score += 5
+            else:
+                score -= 20  # Big penalty for unsafe products
+        
+        return max(0, min(100, score))
+    
+    def _find_best_shades(self, product, skin_tone):
+        """
+        Find the best shade matches within a product line
+        """
+        best_shades = []
+        
+        for shade in product.get('shades', []):
+            shade_score = self._calculate_shade_match(shade, skin_tone)
+            
+            if shade_score > 80:
+                best_shades.append({
+                    'shade': shade,
+                    'score': shade_score,
+                    'reason': self._get_shade_reason(shade, skin_tone)
+                })
+        
+        # Sort by score and return top 3
+        best_shades.sort(key=lambda x: x['score'], reverse=True)
+        return best_shades[:3]
+    
+    def _calculate_shade_match(self, shade, skin_tone):
+        """
+        Calculate how well a specific shade matches
+        """
+        score = 70  # Base score
+        
+        # Compare undertone
+        if shade.get('undertone') == skin_tone['undertone']:
+            score += 15
+        elif self._are_complementary(shade.get('undertone'), skin_tone['undertone']):
+            score += 10  # Complementary colors make features pop
+        
+        # Depth match
+        melanin = skin_tone['melanin_level'] / 100
+        depth_diff = abs(shade.get('depth', 0.5) - melanin)
+        score -= depth_diff * 30
+        
+        return max(0, min(100, score))
+    
+    def _are_complementary(self, shade_undertone, skin_undertone):
+        """
+        Check if undertones are complementary (make each other pop)
+        """
+        complementary_pairs = {
+            'warm': 'cool',
+            'cool': 'warm',
+            'neutral': 'all'
+        }
+        return complementary_pairs.get(shade_undertone) == skin_undertone
+    
+    def _is_safe_for_condition(self, product, condition):
+        """
+        Check if product is safe for specific skin conditions
+        """
+        unsafe_ingredients = {
+            'oily_skin': ['mineral oil', 'coconut oil'],
+            'dry_skin': ['alcohol', 'fragrance'],
+            'sensitive_skin': ['fragrance', 'essential oils', 'alcohol'],
+            'acne': ['isopropyl myristate', 'lanolin']
+        }
+        
+        condition_id = condition.get('condition')
+        if condition_id in unsafe_ingredients:
+            product_ingredients = product.get('ingredients', [])
+            for ingredient in unsafe_ingredients[condition_id]:
+                if ingredient in str(product_ingredients).lower():
+                    return False
+        
+        return True