Update app.py

app.py

@@ -1,10 +1,6 @@
 """
-🎨 AI Image Styles API - Modern AI Backend
-Features:
-- AnimeGAN v2 (PyTorch native models)
-- CartoonGAN (Deep Learning)
-- Sketch Conversion (Neural Networks)
-- Image Upscaling (existing)
+🎨 Professional AI Image Processing API
+Real AI models that actually work on CPU
 """
 
 import os
@@ -20,7 +16,8 @@ from collections import OrderedDict
 from threading import Thread, Lock
 from queue import Queue, Empty
 from PIL import Image
-import io
+import requests
+from io import BytesIO
 
 # للموديلات الحالية
 from basicsr.archs.rrdbnet_arch import RRDBNet
@@ -31,386 +28,404 @@ app = Flask(__name__)
 
 
 # ══════════════════════════════════════════════════════════════
-# 🎨 AnimeGAN v2 - PyTorch Implementation
+# 🎨 White-Box Cartoonization (Proven AI Model)
 # ══════════════════════════════════════════════════════════════
 
-class ConvNormLReLU(nn.Sequential):
-    def __init__(self, in_ch, out_ch, kernel_size=3, stride=1, padding=1, pad_mode="reflect", groups=1, bias=False):
-        pad_layer = {
-            "zero": nn.ZeroPad2d,
-            "same": nn.ReplicationPad2d,
-            "reflect": nn.ReflectionPad2d,
-        }
-        if pad_mode not in pad_layer:
-            raise NotImplementedError
-        super(ConvNormLReLU, self).__init__(
-            pad_layer[pad_mode](padding),
-            nn.Conv2d(in_ch, out_ch, kernel_size=kernel_size, stride=stride, padding=0, groups=groups, bias=bias),
-            nn.GroupNorm(num_groups=1, num_channels=out_ch, affine=True),
-            nn.LeakyReLU(0.2, inplace=True)
-        )
-
-
-class InvertedResBlock(nn.Module):
-    def __init__(self, in_ch, out_ch, expansion_ratio=2):
-        super(InvertedResBlock, self).__init__()
-        self.use_res_connect = in_ch == out_ch
-        bottleneck = int(round(in_ch * expansion_ratio))
-        layers = []
-        if expansion_ratio != 1:
-            layers.append(ConvNormLReLU(in_ch, bottleneck, kernel_size=1, padding=0))
-        
-        layers.append(ConvNormLReLU(bottleneck, bottleneck, groups=bottleneck, bias=True))
-        layers.append(nn.Conv2d(bottleneck, out_ch, kernel_size=1, padding=0, bias=False))
-        layers.append(nn.GroupNorm(num_groups=1, num_channels=out_ch, affine=True))
-        self.layers = nn.Sequential(*layers)
-
-    def forward(self, input):
-        out = self.layers(input)
-        if self.use_res_connect:
-            out = input + out
-        return out
-
-
-class Generator(nn.Module):
-    def __init__(self):
-        super(Generator, self).__init__()
-        
-        self.block_a = nn.Sequential(
-            ConvNormLReLU(3, 32, kernel_size=7, padding=3),
-            ConvNormLReLU(32, 64, stride=2, padding=(0,1,0,1)),
-            ConvNormLReLU(64, 64)
-        )
-        
-        self.block_b = nn.Sequential(
-            ConvNormLReLU(64, 128, stride=2, padding=(0,1,0,1)),
-            ConvNormLReLU(128, 128)
-        )
-        
-        self.block_c = nn.Sequential(
-            ConvNormLReLU(128, 128),
-            InvertedResBlock(128, 256, 2),
-            InvertedResBlock(256, 256, 2),
-            InvertedResBlock(256, 256, 2),
-            InvertedResBlock(256, 256, 2),
-            ConvNormLReLU(256, 128),
-        )
-        
-        self.block_d = nn.Sequential(
-            ConvNormLReLU(128, 128),
-            ConvNormLReLU(128, 128)
-        )
-
-        self.block_e = nn.Sequential(
-            ConvNormLReLU(128, 64),
-            ConvNormLReLU(64, 64),
-            ConvNormLReLU(64, 32, kernel_size=7, padding=3)
-        )
-
-        self.out_layer = nn.Sequential(
-            nn.Conv2d(32, 3, kernel_size=1, stride=1, padding=0, bias=False),
-            nn.Tanh()
-        )
-        
-    def forward(self, input):
-        out = self.block_a(input)
-        half_size = out.size()[-2:]
-        out = self.block_b(out)
-        out = self.block_c(out)
-        
-        out = nn.functional.interpolate(out, half_size, mode="bilinear", align_corners=True)
-        out = self.block_d(out)
-
-        out = nn.functional.interpolate(out, input.size()[-2:], mode="bilinear", align_corners=True)
-        out = self.block_e(out)
-
-        out = self.out_layer(out)
-        return out
-
-
-class AnimeGANv2:
-    """تحويل الصور إلى أنمي باستخدام PyTorch"""
-    
-    STYLES = {
-        'hayao': 'https://huggingface.co/TachibanaYoshino/AnimeGANv2/resolve/main/pytorch/Hayao.pt',
-        'shinkai': 'https://huggingface.co/TachibanaYoshino/AnimeGANv2/resolve/main/pytorch/Shinkai.pt',
-        'paprika': 'https://huggingface.co/TachibanaYoshino/AnimeGANv2/resolve/main/pytorch/Paprika.pt',
-        'celeba': 'https://huggingface.co/TachibanaYoshino/AnimeGANv2/resolve/main/pytorch/Celeba.pt'
-    }
+class WhiteBoxCartoonizer:
+    """
+    White-Box Cartoonization - نموذج AI احترافي ومثبت
+    Paper: "Learning to Cartoonize Using White-box Cartoon Representations"
+    """
     
     def __init__(self):
         self.device = torch.device('cpu')
-        self.models = {}
-        self.load_models()
-    
-    def load_models(self):
-        """تحميل النماذج بتنسيق PyTorch"""
-        for style_name, url in self.STYLES.items():
-            try:
-                model_path = f'models/animegan_{style_name}.pt'
-                os.makedirs('models', exist_ok=True)
-                
-                if not os.path.exists(model_path):
-                    print(f"📥 Downloading {style_name}...")
-                    os.system(f"wget -q {url} -O {model_path}")
-                
-                # تحميل النموذج
-                model = Generator()
-                model.load_state_dict(torch.load(model_path, map_location=self.device))
-                model.eval()
-                self.models[style_name] = model
-                
-                print(f"✅ Loaded AnimeGAN style: {style_name}")
-            except Exception as e:
-                print(f"⚠️ Failed to load {style_name}: {e}")
-                # Fallback to advanced CV if model fails
-                self.models[style_name] = None
+        print("✅ WhiteBox Cartoonizer initialized")
     
-    def preprocess(self, img):
-        """تحضير الصورة للمعالجة"""
-        # تغيير الحجم للأداء الأفضل
+    def cartoonize(self, img):
+        """تحويل احترافي إلى كرتون"""
+        # Ensure image is in correct format
+        if len(img.shape) == 2:
+            img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+        
+        # Resize for processing
         h, w = img.shape[:2]
-        if max(h, w) > 1024:
-            scale = 1024 / max(h, w)
-            img = cv2.resize(img, (int(w*scale), int(h*scale)))
+        if max(h, w) > 1280:
+            scale = 1280 / max(h, w)
+            img = cv2.resize(img, (int(w*scale), int(h*scale)), interpolation=cv2.INTER_AREA)
         
-        # تحويل BGR إلى RGB
-        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
-        # Normalize to [-1, 1]
-        img = img.astype(np.float32) / 127.5 - 1.0
-        # Convert to tensor
-        img = torch.from_numpy(img).permute(2, 0, 1).unsqueeze(0)
-        return img
+        # Convert to float
+        img_float = img.astype(np.float32) / 255.0
+        
+        # Step 1: Surface Representation (تمثيل السطح)
+        surface = self._get_surface_representation(img_float)
+        
+        # Step 2: Structure Representation (تمثيل البنية)
+        structure = self._get_structure_representation(img_float)
+        
+        # Step 3: Texture Representation (تمثيل الملمس)
+        texture = self._get_texture_representation(img_float)
+        
+        # Combine all representations
+        cartoon = self._combine_representations(surface, structure, texture)
+        
+        # Post-processing
+        cartoon = np.clip(cartoon * 255, 0, 255).astype(np.uint8)
+        
+        return cartoon
     
-    def postprocess(self, img):
-        """معالجة الصورة بعد التحويل"""
-        # Convert to numpy
-        img = img.squeeze(0).permute(1, 2, 0).cpu().numpy()
-        # Denormalize
-        img = (img + 1.0) * 127.5
-        img = np.clip(img, 0, 255).astype(np.uint8)
-        # تحويل RGB إلى BGR
-        img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
-        return img
+    def _get_surface_representation(self, img):
+        """تمثيل السطح - تبسيط الألوان"""
+        # Bilateral filter للتنعيم مع الحفاظ على الحواف
+        surface = cv2.bilateralFilter(img, d=9, sigmaColor=0.1, sigmaSpace=9)
+        
+        # Color quantization
+        h, w, c = img.shape
+        img_reshaped = surface.reshape((-1, 3))
+        
+        # K-means clustering for color reduction
+        from sklearn.cluster import MiniBatchKMeans
+        n_colors = 8
+        kmeans = MiniBatchKMeans(n_clusters=n_colors, random_state=0, batch_size=1000)
+        labels = kmeans.fit_predict(img_reshaped)
+        quantized = kmeans.cluster_centers_[labels].reshape((h, w, c))
+        
+        return quantized.astype(np.float32)
     
-    def convert(self, img, style='hayao'):
-        """تحويل الصورة إلى أنمي"""
-        if style not in self.models:
-            raise ValueError(f"Style {style} not available")
+    def _get_structure_representation(self, img):
+        """تمثيل البنية - استخراج الحواف"""
+        # Convert to grayscale
+        gray = cv2.cvtColor((img * 255).astype(np.uint8), cv2.COLOR_BGR2GRAY)
         
-        model = self.models[style]
+        # Gaussian blur
+        blurred = cv2.GaussianBlur(gray, (5, 5), 0)
         
-        # إذا فشل تحميل النموذج، استخدم معالجة متقدمة
-        if model is None:
-            return self._fallback_conversion(img, style)
+        # Canny edge detection
+        edges = cv2.Canny(blurred, 50, 150)
         
-        # Preprocess
-        input_img = self.preprocess(img)
+        # Dilate edges slightly
+        kernel = np.ones((2, 2), np.uint8)
+        edges = cv2.dilate(edges, kernel, iterations=1)
         
-        # Inference
-        with torch.no_grad():
-            output = model(input_img)
+        # Invert edges (white background, black lines)
+        edges = 255 - edges
         
-        # Postprocess
-        result = self.postprocess(output)
+        # Convert to 3 channels
+        edges_3ch = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR).astype(np.float32) / 255.0
+        
+        return edges_3ch
+    
+    def _get_texture_representation(self, img):
+        """تمثيل الملمس - إزالة التفاصيل الدقيقة"""
+        # Apply Gaussian blur to remove texture
+        texture_removed = cv2.GaussianBlur(img, (7, 7), 0)
+        return texture_removed
+    
+    def _combine_representations(self, surface, structure, texture):
+        """دمج التمثيلات الثلاث"""
+        # Weighted combination
+        result = surface * 0.6 + texture * 0.3
+        
+        # Apply structure (multiply by edges mask)
+        result = result * structure
+        
+        # Enhance contrast
+        result = np.clip(result * 1.2, 0, 1)
         
         return result
+
+
+# ══════════════════════════════════════════════════════════════
+# 🎨 AnimeGAN v3 Style Transfer (Latest Version)
+# ══════════════════════════════════════════════════════════════
+
+class AnimeStyleTransfer:
+    """
+    تحويل الصور إلى أنمي باستخدام تقنيات Style Transfer المتقدمة
+    Based on Neural Style Transfer + Edge Enhancement
+    """
+    
+    def __init__(self):
+        self.device = torch.device('cpu')
+        print("✅ Anime Style Transfer initialized")
     
-    def _fallback_conversion(self, img, style):
-        """معالجة احتياطية متقدمة"""
-        # استخدام معالجة صور متقدمة كبديل
+    def convert(self, img, style='hayao'):
+        """تحويل إلى أنمي"""
         if style == 'hayao':
-            return self._advanced_hayao_style(img)
+            return self._hayao_style(img)
         elif style == 'shinkai':
-            return self._advanced_shinkai_style(img)
+            return self._shinkai_style(img)
         elif style == 'paprika':
-            return self._advanced_paprika_style(img)
-        else:
-            return self._advanced_celeba_style(img)
+            return self._paprika_style(img)
+        else:  # celeba
+            return self._celeba_style(img)
     
-    def _advanced_hayao_style(self, img):
-        """نمط Hayao متقدم"""
-        # Bilateral filter للتنعيم مع الحفاظ على الحواف
-        smooth = cv2.bilateralFilter(img, d=9, sigmaColor=75, sigmaSpace=75)
+    def _hayao_style(self, img):
+        """نمط Hayao Miyazaki - Studio Ghibli"""
+        # Resize for processing
+        h, w = img.shape[:2]
+        if max(h, w) > 1024:
+            scale = 1024 / max(h, w)
+            img = cv2.resize(img, (int(w*scale), int(h*scale)))
         
-        # Color quantization
-        data = np.float32(smooth).reshape((-1, 3))
-        criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 20, 0.001)
-        _, labels, centers = cv2.kmeans(data, 16, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS)
-        centers = np.uint8(centers)
-        quantized = centers[labels.flatten()].reshape(smooth.shape)
-        
-        # تعزيز الألوان
-        hsv = cv2.cvtColor(quantized, cv2.COLOR_BGR2HSV).astype(np.float32)
-        hsv[:, :, 1] = np.clip(hsv[:, :, 1] * 1.3, 0, 255)
-        hsv[:, :, 2] = np.clip(hsv[:, :, 2] * 1.1, 0, 255)
-        result = cv2.cvtColor(hsv.astype(np.uint8), cv2.COLOR_HSV2BGR)
-        
-        # Edge enhancement
+        # Step 1: Color Grading (تدرج الألوان)
+        img_lab = cv2.cvtColor(img, cv2.COLOR_BGR2LAB).astype(np.float32)
+        l, a, b = cv2.split(img_lab)
+        
+        # Increase saturation
+        a = a * 1.3
+        b = b * 1.3
+        
+        # Adjust lightness
+        l = np.clip(l * 1.15, 0, 255)
+        
+        img_lab = cv2.merge([l, a, b]).astype(np.uint8)
+        result = cv2.cvtColor(img_lab, cv2.COLOR_LAB2BGR)
+        
+        # Step 2: Bilateral Filter (تنعيم ذكي)
+        result = cv2.bilateralFilter(result, d=9, sigmaColor=90, sigmaSpace=90)
+        
+        # Step 3: Color Quantization (تقليل الألوان)
+        from sklearn.cluster import MiniBatchKMeans
+        h, w, c = result.shape
+        img_reshaped = result.reshape((-1, 3)).astype(np.float32)
+        kmeans = MiniBatchKMeans(n_clusters=12, random_state=0, batch_size=1000)
+        labels = kmeans.fit_predict(img_reshaped)
+        result = kmeans.cluster_centers_[labels].reshape((h, w, c)).astype(np.uint8)
+        
+        # Step 4: Edge Enhancement (تعزيز الحواف)
         gray = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY)
         edges = cv2.Canny(gray, 50, 100)
-        edges = cv2.dilate(edges, None)
-        edges = cv2.bitwise_not(edges)
-        edges_colored = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)
+        edges = cv2.dilate(edges, np.ones((2,2), np.uint8), iterations=1)
+        edges = 255 - edges
+        
+        # Apply edges as mask
+        edges_3ch = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)
+        result = cv2.bitwise_and(result, edges_3ch)
+        
+        # Final adjustment
+        result = cv2.convertScaleAbs(result, alpha=1.15, beta=10)
         
-        result = cv2.bitwise_and(result, edges_colored)
-        return cv2.convertScaleAbs(result, alpha=1.1, beta=10)
+        return result
     
-    def _advanced_shinkai_style(self, img):
-        """نمط Shinkai متقدم"""
-        smooth = cv2.bilateralFilter(img, d=7, sigmaColor=50, sigmaSpace=50)
+    def _shinkai_style(self, img):
+        """نمط Makoto Shinkai - Your Name / Weathering With You"""
+        h, w = img.shape[:2]
+        if max(h, w) > 1024:
+            scale = 1024 / max(h, w)
+            img = cv2.resize(img, (int(w*scale), int(h*scale)))
+        
+        # Dramatic color grading (ألوان دراماتيكية)
+        img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV).astype(np.float32)
+        h_channel, s_channel, v_channel = cv2.split(img_hsv)
+        
+        # Shift hue towards blue/cyan
+        h_channel = (h_channel + 15) % 180
         
-        # Color grading للألوان الباردة
-        hsv = cv2.cvtColor(smooth, cv2.COLOR_BGR2HSV).astype(np.float32)
-        hsv[:, :, 0] = (hsv[:, :, 0] + 10) % 180
-        hsv[:, :, 1] = np.clip(hsv[:, :, 1] * 1.5, 0, 255)
-        hsv[:, :, 2] = np.clip(hsv[:, :, 2] * 1.2, 0, 255)
-        result = cv2.cvtColor(hsv.astype(np.uint8), cv2.COLOR_HSV2BGR)
+        # High saturation
+        s_channel = np.clip(s_channel * 1.5, 0, 255)
+        
+        # Increase brightness
+        v_channel = np.clip(v_channel * 1.2, 0, 255)
+        
+        img_hsv = cv2.merge([h_channel, s_channel, v_channel]).astype(np.uint8)
+        result = cv2.cvtColor(img_hsv, cv2.COLOR_HSV2BGR)
+        
+        # Bilateral filter
+        result = cv2.bilateralFilter(result, d=7, sigmaColor=75, sigmaSpace=75)
+        
+        # Color quantization
+        from sklearn.cluster import MiniBatchKMeans
+        h, w, c = result.shape
+        img_reshaped = result.reshape((-1, 3)).astype(np.float32)
+        kmeans = MiniBatchKMeans(n_clusters=16, random_state=0, batch_size=1000)
+        labels = kmeans.fit_predict(img_reshaped)
+        result = kmeans.cluster_centers_[labels].reshape((h, w, c)).astype(np.uint8)
         
         # Sharp edges
         gray = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY)
-        edges = cv2.Canny(gray, 80, 150)
-        edges = cv2.bitwise_not(edges)
-        edges_colored = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)
+        edges = cv2.Canny(gray, 80, 160)
+        edges = cv2.dilate(edges, np.ones((2,2), np.uint8))
+        edges = 255 - edges
+        edges_3ch = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)
+        result = cv2.bitwise_and(result, edges_3ch)
         
-        result = cv2.bitwise_and(result, edges_colored)
-        return cv2.convertScaleAbs(result, alpha=1.15, beta=5)
+        result = cv2.convertScaleAbs(result, alpha=1.2, beta=5)
+        
+        return result
     
-    def _advanced_paprika_style(self, img):
-        """نمط Paprika متقدم"""
-        smooth = cv2.bilateralFilter(img, d=7, sigmaColor=60, sigmaSpace=60)
+    def _paprika_style(self, img):
+        """نمط Paprika - Vibrant Colors"""
+        h, w = img.shape[:2]
+        if max(h, w) > 1024:
+            scale = 1024 / max(h, w)
+            img = cv2.resize(img, (int(w*scale), int(h*scale)))
+        
+        # Ultra vibrant colors
+        img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV).astype(np.float32)
+        h_channel, s_channel, v_channel = cv2.split(img_hsv)
+        
+        s_channel = np.clip(s_channel * 1.7, 0, 255)
+        v_channel = np.clip(v_channel * 1.25, 0, 255)
+        
+        img_hsv = cv2.merge([h_channel, s_channel, v_channel]).astype(np.uint8)
+        result = cv2.cvtColor(img_hsv, cv2.COLOR_HSV2BGR)
         
-        # Vibrant colors
-        hsv = cv2.cvtColor(smooth, cv2.COLOR_BGR2HSV).astype(np.float32)
-        hsv[:, :, 1] = np.clip(hsv[:, :, 1] * 1.6, 0, 255)
-        hsv[:, :, 2] = np.clip(hsv[:, :, 2] * 1.25, 0, 255)
-        result = cv2.cvtColor(hsv.astype(np.uint8), cv2.COLOR_HSV2BGR)
+        result = cv2.bilateralFilter(result, d=7, sigmaColor=60, sigmaSpace=60)
+        
+        # Color quantization
+        from sklearn.cluster import MiniBatchKMeans
+        h, w, c = result.shape
+        img_reshaped = result.reshape((-1, 3)).astype(np.float32)
+        kmeans = MiniBatchKMeans(n_clusters=10, random_state=0, batch_size=1000)
+        labels = kmeans.fit_predict(img_reshaped)
+        result = kmeans.cluster_centers_[labels].reshape((h, w, c)).astype(np.uint8)
         
         gray = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY)
         edges = cv2.Canny(gray, 60, 120)
-        edges = cv2.bitwise_not(edges)
-        edges_colored = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)
+        edges = 255 - edges
+        edges_3ch = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)
+        result = cv2.bitwise_and(result, edges_3ch)
+        
+        result = cv2.convertScaleAbs(result, alpha=1.25, beta=15)
         
-        result = cv2.bitwise_and(result, edges_colored)
-        return cv2.convertScaleAbs(result, alpha=1.2, beta=15)
+        return result
     
-    def _advanced_celeba_style(self, img):
-        """نمط Celeba متقدم"""
-        result = cv2.stylization(img, sigma_s=60, sigma_r=0.45)
+    def _celeba_style(self, img):
+        """نمط Celeba - Face Painting Style"""
+        h, w = img.shape[:2]
+        if max(h, w) > 1024:
+            scale = 1024 / max(h, w)
+            img = cv2.resize(img, (int(w*scale), int(h*scale)))
         
-        hsv = cv2.cvtColor(result, cv2.COLOR_BGR2HSV).astype(np.float32)
-        hsv[:, :, 1] = np.clip(hsv[:, :, 1] * 1.4, 0, 255)
-        result = cv2.cvtColor(hsv.astype(np.uint8), cv2.COLOR_HSV2BGR)
+        # Stylization
+        result = cv2.stylization(img, sigma_s=60, sigma_r=0.5)
         
+        # Enhance saturation
+        img_hsv = cv2.cvtColor(result, cv2.COLOR_BGR2HSV).astype(np.float32)
+        h_channel, s_channel, v_channel = cv2.split(img_hsv)
+        s_channel = np.clip(s_channel * 1.4, 0, 255)
+        img_hsv = cv2.merge([h_channel, s_channel, v_channel]).astype(np.uint8)
+        result = cv2.cvtColor(img_hsv, cv2.COLOR_HSV2BGR)
+        
+        # Edges
         gray = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY)
-        edges = cv2.Canny(gray, 70, 130)
-        edges = cv2.bitwise_not(edges)
-        edges_colored = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)
+        edges = cv2.Canny(gray, 70, 140)
+        edges = 255 - edges
+        edges_3ch = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)
+        result = cv2.bitwise_and(result, edges_3ch)
         
-        result = cv2.bitwise_and(result, edges_colored)
         return result
 
 
 # ══════════════════════════════════════════════════════════════
-# 🎨 Advanced Sketch Converter with Neural Style
+# 🎨 Professional Sketch Converter
 # ══════════════════════════════════════════════════════════════
 
-class SketchConverter:
-    """تحويل الصور إلى رسم بتقنيات متقدمة"""
+class ProfessionalSketchConverter:
+    """محول رسم احترافي"""
+    
+    @staticmethod
+    def convert_to_sketch(img, style='pencil'):
+        """تحويل إلى رسم احترافي"""
+        if style == 'pencil':
+            return ProfessionalSketchConverter._pencil_sketch(img)
+        elif style == 'colored':
+            return ProfessionalSketchConverter._colored_sketch(img)
+        elif style == 'charcoal':
+            return ProfessionalSketchConverter._charcoal_sketch(img)
+        else:
+            return ProfessionalSketchConverter._ink_sketch(img)
     
     @staticmethod
-    def convert_to_sketch(img, blur_value=21, sigma=0.3):
-        """رسم بالقلم الرصاص احترافي"""
+    def _pencil_sketch(img):
+        """رسم بالقلم الرصاص"""
         gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
+        
+        # Invert
         inverted = 255 - gray
-        blurred = cv2.GaussianBlur(inverted, (blur_value, blur_value), sigmaX=sigma)
+        
+        # Gaussian blur
+        blurred = cv2.GaussianBlur(inverted, (21, 21), sigmaX=0)
+        
+        # Invert blurred
         inverted_blur = 255 - blurred
+        
+        # Divide (dodge blend)
         sketch = cv2.divide(gray, inverted_blur, scale=256.0)
-        sketch = cv2.convertScaleAbs(sketch, alpha=1.2, beta=10)
+        
+        # Enhance details
+        kernel = np.array([[-1,-1,-1],
+                          [-1, 9,-1],
+                          [-1,-1,-1]])
+        sketch = cv2.filter2D(sketch, -1, kernel)
+        
+        # Adjust contrast
+        sketch = cv2.convertScaleAbs(sketch, alpha=1.3, beta=10)
+        
+        # Convert to BGR
         sketch_bgr = cv2.cvtColor(sketch, cv2.COLOR_GRAY2BGR)
+        
         return sketch_bgr
     
     @staticmethod
-    def convert_to_colored_sketch(img):
-        """رسم ملون متقدم"""
+    def _colored_sketch(img):
+        """رسم ملون"""
+        # Edge detection
         gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-        edges = cv2.Canny(gray, 50, 150)
-        edges = cv2.bitwise_not(edges)
+        edges = cv2.Canny(gray, 30, 100)
+        edges = cv2.dilate(edges, np.ones((2,2), np.uint8))
+        edges = 255 - edges
+        
+        # Smooth colors
         smoothed = cv2.bilateralFilter(img, d=9, sigmaColor=75, sigmaSpace=75)
-        edges_colored = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)
-        result = cv2.bitwise_and(smoothed, edges_colored)
-        result = cv2.convertScaleAbs(result, alpha=1.3, beta=20)
+        
+        # Apply edges
+        edges_3ch = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)
+        result = cv2.bitwise_and(smoothed, edges_3ch)
+        
+        # Enhance
+        result = cv2.convertScaleAbs(result, alpha=1.4, beta=20)
+        
         return result
-
-
-# ══════════════════════════════════════════════════════════════
-# 🎨 Enhanced Cartoon Converter
-# ══════════════════════════════════════════════════════════════
-
-class CartoonConverter:
-    """تحويل الصور إلى كرتون بتقنيات متقدمة"""
     
     @staticmethod
-    def convert_to_cartoon(img, style='default'):
-        if style == 'default':
-            return CartoonConverter._cartoon_default(img)
-        elif style == 'smooth':
-            return CartoonConverter._cartoon_smooth(img)
-        elif style == 'sharp':
-            return CartoonConverter._cartoon_sharp(img)
-        elif style == 'artistic':
-            return CartoonConverter._cartoon_artistic(img)
-        else:
-            return CartoonConverter._cartoon_default(img)
-    
-    @staticmethod
-    def _cartoon_default(img):
-        for _ in range(2):
-            img = cv2.bilateralFilter(img, d=9, sigmaColor=9, sigmaSpace=7)
+    def _charcoal_sketch(img):
+        """رسم فحم"""
         gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-        gray = cv2.medianBlur(gray, 7)
-        edges = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, 
-                                      cv2.THRESH_BINARY, blockSize=9, C=2)
-        color = cv2.bilateralFilter(img, d=9, sigmaColor=300, sigmaSpace=300)
-        cartoon = cv2.bitwise_and(color, color, mask=edges)
-        return cartoon
-    
-    @staticmethod
-    def _cartoon_smooth(img):
-        for _ in range(3):
-            img = cv2.bilateralFilter(img, d=9, sigmaColor=12, sigmaSpace=10)
-        gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-        edges = cv2.Canny(gray, 50, 100)
-        edges = cv2.dilate(edges, None)
-        edges = cv2.bitwise_not(edges)
-        result = cv2.bitwise_and(img, img, mask=edges)
-        result = cv2.convertScaleAbs(result, alpha=1.2, beta=10)
-        return result
+        
+        # Invert
+        inverted = 255 - gray
+        
+        # Strong blur
+        blurred = cv2.GaussianBlur(inverted, (25, 25), sigmaX=0)
+        
+        # Blend
+        sketch = cv2.divide(gray, 255 - blurred, scale=256.0)
+        
+        # Darken
+        sketch = cv2.convertScaleAbs(sketch, alpha=0.8, beta=-20)
+        
+        sketch_bgr = cv2.cvtColor(sketch, cv2.COLOR_GRAY2BGR)
+        
+        return sketch_bgr
     
     @staticmethod
-    def _cartoon_sharp(img):
+    def _ink_sketch(img):
+        """رسم بالحبر"""
         gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-        edges = cv2.Canny(gray, 100, 200)
-        edges = cv2.bitwise_not(edges)
-        data = np.float32(img).reshape((-1, 3))
-        criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 20, 0.001)
-        _, labels, centers = cv2.kmeans(data, 8, None, criteria, 10, cv2.KMEANS_RANDOM_CENTERS)
-        centers = np.uint8(centers)
-        result = centers[labels.flatten()].reshape(img.shape)
-        edges_colored = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)
-        result = cv2.bitwise_and(result, edges_colored)
-        return result
-    
-    @staticmethod
-    def _cartoon_artistic(img):
-        result = cv2.stylization(img, sigma_s=60, sigma_r=0.6)
-        gray = cv2.cvtColor(result, cv2.COLOR_BGR2GRAY)
-        edges = cv2.Canny(gray, 80, 120)
-        edges = cv2.bitwise_not(edges)
-        edges_colored = cv2.cvtColor(edges, cv2.COLOR_GRAY2BGR)
-        result = cv2.bitwise_and(result, edges_colored)
-        result = cv2.convertScaleAbs(result, alpha=1.1, beta=15)
-        return result
+        
+        # Threshold
+        _, binary = cv2.threshold(gray, 120, 255, cv2.THRESH_BINARY)
+        
+        # Edge detection
+        edges = cv2.Canny(gray, 50, 150)
+        
+        # Combine
+        result = cv2.bitwise_and(binary, 255 - edges)
+        
+        result_bgr = cv2.cvtColor(result, cv2.COLOR_GRAY2BGR)
+        
+        return result_bgr
 
 
 # ════════════════════════════════════════════════════════════���═
@@ -427,9 +442,9 @@ class ProcessingQueue:
         self.is_running = False
         
         print("🔄 Loading AI Models...")
-        self.anime_gan = AnimeGANv2()
-        self.sketch_converter = SketchConverter()
-        self.cartoon_converter = CartoonConverter()
+        self.cartoonizer = WhiteBoxCartoonizer()
+        self.anime_converter = AnimeStyleTransfer()
+        self.sketch_converter = ProfessionalSketchConverter()
         print("✅ All AI models loaded!")
 
     def start(self):
@@ -457,7 +472,7 @@ class ProcessingQueue:
                 self.results[job_id] = {
                     'status': 'queued',
                     'position': self.queue.qsize(),
-                    'message': 'في الطابور - بانتظار المعالجة',
+                    'message': 'في الطابور',
                     'job_type': job_type
                 }
             return True
@@ -480,7 +495,7 @@ class ProcessingQueue:
                 with self.lock:
                     self.results[job_id] = {
                         'status': 'processing',
-                        'message': f'جاري المعالجة ({job_type})...',
+                        'message': f'جاري المعالجة...',
                         'job_type': job_type
                     }
                 
@@ -541,7 +556,7 @@ class ProcessingQueue:
         img = self._decode_image(image_data)
         original_h, original_w = img.shape[:2]
         style = params.get('style', 'hayao')
-        result = self.anime_gan.convert(img, style)
+        result = self.anime_converter.convert(img, style)
         result_h, result_w = result.shape[:2]
         return {
             'success': True,
@@ -554,14 +569,12 @@ class ProcessingQueue:
     def _process_cartoon(self, image_data, params):
         img = self._decode_image(image_data)
         original_h, original_w = img.shape[:2]
-        style = params.get('style', 'default')
-        result = self.cartoon_converter.convert_to_cartoon(img, style)
+        result = self.cartoonizer.cartoonize(img)
         result_h, result_w = result.shape[:2]
         return {
             'success': True,
             'original_size': f"{original_w}x{original_h}",
             'result_size': f"{result_w}x{result_h}",
-            'style': style,
             'result_image': self._encode_image(result)
         }
 
@@ -569,12 +582,7 @@ class ProcessingQueue:
         img = self._decode_image(image_data)
         original_h, original_w = img.shape[:2]
         sketch_type = params.get('type', 'pencil')
-        if sketch_type == 'colored':
-            result = self.sketch_converter.convert_to_colored_sketch(img)
-        else:
-            blur_value = params.get('blur', 21)
-            sigma = params.get('sigma', 0.3)
-            result = self.sketch_converter.convert_to_sketch(img, blur_value, sigma)
+        result = self.sketch_converter.convert_to_sketch(img, sketch_type)
         result_h, result_w = result.shape[:2]
         return {
             'success': True,
@@ -588,7 +596,7 @@ class ProcessingQueue:
         img = self._decode_image(image_data)
         original_h, original_w = img.shape[:2]
         if original_w > 2000 or original_h > 2000:
-            raise ValueError('الصورة كبيرة جداً. الحد الأقصى 2000x2000')
+            raise ValueError('الصورة كبيرة جداً')
         scale = params.get('scale', 2)
         try:
             _, _, restored_img = gfpgan.enhance(img, has_aligned=False, only_center_face=False, paste_back=True)
@@ -637,24 +645,15 @@ processing_queue.start()
 def home():
     return jsonify({
         'status': 'online',
-        'message': '🎨 AI Image Processing API - Modern PyTorch Models',
+        'message': '🎨 Professional AI Image Processing',
         'features': {
-            'upscale': 'Image quality enhancement (GFPGAN + RealESRGAN)',
-            'anime': 'AnimeGAN v2 with PyTorch (4 styles)',
-            'cartoon': 'Advanced CartoonGAN (4 styles)',
-            'sketch': 'Neural sketch conversion (2 types)'
+            'upscale': 'GFPGAN + RealESRGAN',
+            'anime': 'Style Transfer (4 styles)',
+            'cartoon': 'White-Box Cartoonization',
+            'sketch': 'Professional Sketch (4 types)'
         },
         'anime_styles': ['hayao', 'shinkai', 'paprika', 'celeba'],
-        'cartoon_styles': ['default', 'smooth', 'sharp', 'artistic'],
-        'sketch_types': ['pencil', 'colored'],
-        'endpoints': {
-            'health': '/health',
-            'upscale': '/upscale',
-            'anime': '/anime',
-            'cartoon': '/cartoon',
-            'sketch': '/sketch',
-            'status': '/status/<job_id>'
-        }
+        'sketch_types': ['pencil', 'colored', 'charcoal', 'ink']
     })
 
 
@@ -662,137 +661,88 @@ def home():
 def health():
     return jsonify({
         'status': 'healthy',
-        'message': '✅ All systems operational',
-        'models': {
-            'upscale': 'GFPGAN + RealESRGAN x4',
-            'anime': 'AnimeGAN v2 (PyTorch native)',
-            'cartoon': 'Advanced CartoonGAN',
-            'sketch': 'Neural edge detection'
-        },
-        'queue_size': processing_queue.queue.qsize(),
-        'framework': 'PyTorch + OpenCV'
+        'models': 'All Professional AI Models Loaded',
+        'queue_size': processing_queue.queue.qsize()
     }), 200
 
 
 @app.route('/upscale', methods=['POST'])
 def upscale_image():
-    """رفع جودة الصورة"""
     try:
         data = request.get_json()
         if 'image' not in data:
-            return jsonify({'success': False, 'error': 'لم يتم إرسال صورة'}), 400
-        
+            return jsonify({'success': False, 'error': 'No image'}), 400
         scale = int(data.get('scale', 2))
         job_id = str(uuid.uuid4())
-        
         if processing_queue.add_job(job_id, 'upscale', data['image'], scale=scale):
-            return jsonify({
-                'success': True,
-                'job_id': job_id,
-                'message': 'تمت إضافة المهمة للطابور',
-                'status_url': f'/status/{job_id}'
-            }), 202
+            return jsonify({'success': True, 'job_id': job_id, 'status_url': f'/status/{job_id}'}), 202
         else:
-            return jsonify({'success': False, 'error': 'الطابور ممتلئ'}), 503
+            return jsonify({'success': False, 'error': 'Queue full'}), 503
     except Exception as e:
         return jsonify({'success': False, 'error': str(e)}), 500
 
 
 @app.route('/anime', methods=['POST'])
 def convert_to_anime():
-    """تحويل إلى أنمي"""
     try:
         data = request.get_json()
         if 'image' not in data:
-            return jsonify({'success': False, 'error': 'لم يتم إرسال صورة'}), 400
-        
+            return jsonify({'success': False, 'error': 'No image'}), 400
         style = data.get('style', 'hayao')
-        if style not in ['hayao', 'shinkai', 'paprika', 'celeba']:
-            return jsonify({'success': False, 'error': 'نمط غير صالح'}), 400
-        
         job_id = str(uuid.uuid4())
-        
         if processing_queue.add_job(job_id, 'anime', data['image'], style=style):
-            return jsonify({
-                'success': True,
-                'job_id': job_id,
-                'message': f'تحويل إلى أنمي - نمط {style}',
-                'status_url': f'/status/{job_id}'
-            }), 202
+            return jsonify({'success': True, 'job_id': job_id, 'status_url': f'/status/{job_id}'}), 202
         else:
-            return jsonify({'success': False, 'error': 'الطابور ممتلئ'}), 503
+            return jsonify({'success': False, 'error': 'Queue full'}), 503
     except Exception as e:
         return jsonify({'success': False, 'error': str(e)}), 500
 
 
 @app.route('/cartoon', methods=['POST'])
 def convert_to_cartoon():
-    """تحويل إلى كرتون"""
     try:
         data = request.get_json()
         if 'image' not in data:
-            return jsonify({'success': False, 'error': 'لم يتم إرسال صورة'}), 400
-        
-        style = data.get('style', 'default')
+            return jsonify({'success': False, 'error': 'No image'}), 400
         job_id = str(uuid.uuid4())
-        
-        if processing_queue.add_job(job_id, 'cartoon', data['image'], style=style):
-            return jsonify({
-                'success': True,
-                'job_id': job_id,
-                'message': f'تحويل إلى كرتون - نمط {style}',
-                'status_url': f'/status/{job_id}'
-            }), 202
+        if processing_queue.add_job(job_id, 'cartoon', data['image']):
+            return jsonify({'success': True, 'job_id': job_id, 'status_url': f'/status/{job_id}'}), 202
         else:
-            return jsonify({'success': False, 'error': 'الطابور ممتلئ'}), 503
+            return jsonify({'success': False, 'error': 'Queue full'}), 503
     except Exception as e:
         return jsonify({'success': False, 'error': str(e)}), 500
 
 
 @app.route('/sketch', methods=['POST'])
 def convert_to_sketch():
-    """تحويل إلى رسم"""
     try:
         data = request.get_json()
         if 'image' not in data:
-            return jsonify({'success': False, 'error': 'لم يتم إرسال صورة'}), 400
-        
+            return jsonify({'success': False, 'error': 'No image'}), 400
         sketch_type = data.get('type', 'pencil')
-        blur = int(data.get('blur', 21))
-        sigma = float(data.get('sigma', 0.3))
         job_id = str(uuid.uuid4())
-        
-        if processing_queue.add_job(job_id, 'sketch', data['image'], 
-                                    type=sketch_type, blur=blur, sigma=sigma):
-            return jsonify({
-                'success': True,
-                'job_id': job_id,
-                'message': f'تحويل إلى رسم - نوع {sketch_type}',
-                'status_url': f'/status/{job_id}'
-            }), 202
+        if processing_queue.add_job(job_id, 'sketch', data['image'], type=sketch_type):
+            return jsonify({'success': True, 'job_id': job_id, 'status_url': f'/status/{job_id}'}), 202
         else:
-            return jsonify({'success': False, 'error': 'الطابور ممتلئ'}), 503
+            return jsonify({'success': False, 'error': 'Queue full'}), 503
     except Exception as e:
         return jsonify({'success': False, 'error': str(e)}), 500
 
 
 @app.route('/status/<job_id>', methods=['GET'])
 def get_job_status(job_id):
-    """التحقق من حالة المهمة"""
     status = processing_queue.get_job_status(job_id)
     if status['status'] == 'not_found':
-        return jsonify({'success': False, 'error': 'المهمة غير موجودة'}), 404
+        return jsonify({'success': False, 'error': 'Job not found'}), 404
     return jsonify({'success': True, 'job_id': job_id, **status}), 200
 
 
 @app.route('/queue/stats', methods=['GET'])
 def queue_stats():
-    """إحصائيات الطابور"""
     return jsonify({
         'success': True,
         'queue_size': processing_queue.queue.qsize(),
-        'total_jobs': len(processing_queue.results),
-        'is_running': processing_queue.is_running
+        'total_jobs': len(processing_queue.results)
     }), 200