Delete cosmetics_matching.py

cosmetics_matching.py

@@ -1,274 +0,0 @@
-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