Create contentClassifier.py

contentClassifier.py

@@ -0,0 +1,176 @@
+# contentClassifier.py - Lightweight Content Detection
+# FROZEN - DO NOT MODIFY
+
+import numpy as np
+from PIL import Image
+from collections import Counter
+
+class ContentClassifier:
+    """Lightweight content detection - FROZEN."""
+    
+    def __init__(self):
+        self.categories = [
+            'simple_graphic', 'human_hair', 'human', 'anime',
+            'logo_icon', 'product_white_bg', 'general_photo', 'complex'
+        ]
+    
+    def classify(self, image: Image.Image) -> dict:
+        """Classify image content."""
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        small = image.copy()
+        small.thumbnail((150, 150), Image.Resampling.LANCZOS)
+        np_img = np.array(small)
+        h, w = np_img.shape[:2]
+        
+        signals = {
+            'dimensions': (w, h),
+            'aspect_ratio': h / w if w > 0 else 0,
+            'border_uniformity': self._border_uniformity(np_img),
+            'edge_density': self._edge_density(np_img),
+            'color_complexity': self._color_complexity(small),
+            'skin_score': self._skin_score(np_img),
+            'border_connected': self._border_connected(np_img),
+            'texture': self._texture(np_img)
+        }
+        
+        category = self._classify(signals)
+        confidence = self._calculate_confidence(category, signals)
+        
+        return {
+            'category': category,
+            'confidence': confidence,
+            'signals': signals
+        }
+    
+    def _border_uniformity(self, np_img: np.ndarray) -> float:
+        h, w = np_img.shape[:2]
+        border_pixels = []
+        step = max(1, min(h, w) // 10)
+        
+        for x in range(0, w, step):
+            border_pixels.append(tuple(np_img[0, x][:3]))
+            border_pixels.append(tuple(np_img[h-1, x][:3]))
+        for y in range(0, h, step):
+            border_pixels.append(tuple(np_img[y, 0][:3]))
+            border_pixels.append(tuple(np_img[y, w-1][:3]))
+        
+        if not border_pixels:
+            return 0.0
+        
+        unique = len(set(border_pixels))
+        return 1 - (unique / len(border_pixels))
+    
+    def _edge_density(self, np_img: np.ndarray) -> float:
+        gray = np.mean(np_img, axis=2).astype(np.float32)
+        grad_x = np.abs(gray[:, 1:] - gray[:, :-1])
+        grad_y = np.abs(gray[1:, :] - gray[:-1, :])
+        
+        edges = (grad_x > 25).sum() + (grad_y > 25).sum()
+        total = (gray.shape[0] - 1) * gray.shape[1] + gray.shape[0] * (gray.shape[1] - 1)
+        
+        return edges / total if total > 0 else 0
+    
+    def _color_complexity(self, image: Image.Image) -> float:
+        quantized = image.quantize(colors=32)
+        unique = len(quantized.getcolors())
+        return min(1.0, unique / 32)
+    
+    def _skin_score(self, np_img: np.ndarray) -> float:
+        h, w = np_img.shape[:2]
+        pixels = []
+        step = max(1, min(h, w) // 5)
+        for y in range(0, h, step):
+            for x in range(0, w, step):
+                pixels.append(np_img[y, x][:3])
+        
+        skin = 0
+        for r, g, b in pixels:
+            if (r > 60 and g > 40 and b > 20 and
+                r > g and r > b and
+                abs(r - g) < 60 and abs(r - b) < 60):
+                skin += 1
+        
+        return skin / len(pixels) if pixels else 0
+    
+    def _border_connected(self, np_img: np.ndarray) -> float:
+        h, w = np_img.shape[:2]
+        border_colors = set()
+        border_colors.add(tuple(np_img[0, 0][:3]))
+        border_colors.add(tuple(np_img[0, w-1][:3]))
+        border_colors.add(tuple(np_img[h-1, 0][:3]))
+        border_colors.add(tuple(np_img[h-1, w-1][:3]))
+        
+        interior_colors = set()
+        step = max(1, min(h, w) // 4)
+        for y in range(h//4, 3*h//4, step):
+            for x in range(w//4, 3*w//4, step):
+                interior_colors.add(tuple(np_img[y, x][:3]))
+        
+        overlap = border_colors & interior_colors
+        return len(overlap) / max(len(border_colors), 1)
+    
+    def _texture(self, np_img: np.ndarray) -> float:
+        gray = np.mean(np_img, axis=2).astype(np.float32)
+        variance = np.var(gray)
+        return min(1.0, variance / 5000)
+    
+    def _classify(self, signals: dict) -> str:
+        s = signals
+        
+        # Simple graphic
+        if (s['color_complexity'] < 0.3 and 
+            s['edge_density'] > 0.3 and 
+            s['border_uniformity'] > 0.7):
+            return 'simple_graphic'
+        
+        # Human with hair
+        if (s['skin_score'] > 0.15 and 
+            s['texture'] > 0.3 and 
+            s['edge_density'] > 0.2):
+            return 'human_hair'
+        
+        # Human
+        if s['skin_score'] > 0.1:
+            return 'human'
+        
+        # Anime
+        if (s['skin_score'] < 0.08 and 
+            s['color_complexity'] > 0.3 and 
+            s['texture'] < 0.3 and 
+            s['edge_density'] > 0.3):
+            return 'anime'
+        
+        # Logo/icon
+        if (s['edge_density'] > 0.4 and 
+            s['color_complexity'] < 0.3 and 
+            s['border_uniformity'] > 0.6):
+            return 'logo_icon'
+        
+        # Product on white bg
+        if (s['border_uniformity'] > 0.6 and 
+            s['color_complexity'] < 0.5 and 
+            s['edge_density'] < 0.4):
+            return 'product_white_bg'
+        
+        # General photo
+        if s['color_complexity'] > 0.3:
+            return 'general_photo'
+        
+        return 'complex'
+    
+    def _calculate_confidence(self, category: str, signals: dict) -> float:
+        base = 0.7
+        
+        if category == 'simple_graphic':
+            if signals['border_uniformity'] > 0.8:
+                base += 0.2
+        elif category == 'human_hair':
+            if signals['skin_score'] > 0.2 and signals['texture'] > 0.4:
+                base += 0.2
+        elif category == 'human':
+            if signals['skin_score'] > 0.15:
+                base += 0.2
+        
+        return min(1.0, base)