Delete image_processing.py

image_processing.py

@@ -1,251 +0,0 @@
-# ==========================================
-# image_processing.py - Calcul OCR v3.0 CLEAN
-# ==========================================
-
-"""
-Module de traitement d'images pour calculs mathématiques - EasyOCR UNIQUEMENT
-"""
-
-from PIL import Image, ImageEnhance
-import numpy as np
-import base64
-from io import BytesIO
-import gc
-import os
-import time
-
-# Variables globales pour OCR EasyOCR uniquement
-easyocr_reader = None
-
-def init_ocr_model() -> bool:
-    """Initialise EasyOCR (rapide et efficace sur CPU)"""
-    global easyocr_reader
-    
-    try:
-        print("🔄 Chargement EasyOCR (optimisé CPU)...")
-        import easyocr
-        easyocr_reader = easyocr.Reader(['en'], gpu=False)  # Force CPU pour compatibilité
-        print("✅ EasyOCR prêt !")
-        return True
-        
-    except Exception as e:
-        print(f"❌ Erreur lors du chargement EasyOCR: {e}")
-        return False
-
-def create_white_canvas(width: int = 300, height: int = 300) -> Image.Image:
-    """Crée un canvas blanc pour le dessin de calculs"""
-    return Image.new('RGB', (width, height), 'white')
-
-def log_memory_usage(context: str = "") -> None:
-    """Log l'usage mémoire actuel"""
-    try:
-        import psutil
-        process = psutil.Process(os.getpid())
-        memory_mb = process.memory_info().rss / 1024 / 1024
-        print(f"🔍 Mémoire {context}: {memory_mb:.1f}MB")
-    except:
-        pass
-
-def cleanup_memory() -> None:
-    """Force le nettoyage mémoire"""
-    gc.collect()
-
-def optimize_image_for_ocr(image_dict: dict | np.ndarray | Image.Image | None) -> Image.Image | None:
-    """Optimisation image pour reconnaissance de nombres avec EasyOCR"""
-    if image_dict is None:
-        return None
-
-    try:
-        # Gérer les formats Gradio
-        if isinstance(image_dict, dict):
-            if 'composite' in image_dict and image_dict['composite'] is not None:
-                image = image_dict['composite']
-            elif 'background' in image_dict and image_dict['background'] is not None:
-                image = image_dict['background']
-            else:
-                return None
-        elif isinstance(image_dict, np.ndarray):
-            image = image_dict
-        elif isinstance(image_dict, Image.Image):
-            image = image_dict
-        else:
-            return None
-
-        # Conversion
-        if isinstance(image, np.ndarray):
-            pil_image = Image.fromarray(image).convert('RGB')
-        else:
-            pil_image = image.convert('RGB')
-
-        # Redimensionner si nécessaire pour optimiser OCR
-        max_size = 300
-        if pil_image.size[0] > max_size or pil_image.size[1] > max_size:
-            pil_image.thumbnail((max_size, max_size), Image.Resampling.LANCZOS)
-
-        return pil_image
-
-    except Exception:
-        return None
-
-def prepare_image_for_dataset(image: Image.Image, max_size: tuple[int, int] = (100, 100), quality: int = 60) -> dict[str, str | int | float | tuple] | None:
-    """Prépare image pour dataset calcul OCR"""
-    try:
-        if image is None:
-            return None
-            
-        # Copier et redimensionner
-        dataset_image = image.copy()
-        dataset_image.thumbnail(max_size, Image.Resampling.LANCZOS)
-        compressed_size = dataset_image.size
-        
-        # Convertir en base64
-        buffer = BytesIO()
-        dataset_image.save(buffer, format='PNG', optimize=True, quality=quality)
-        
-        buffer_data = buffer.getvalue()
-        image_base64 = base64.b64encode(buffer_data).decode()
-        file_size_kb = len(image_base64) / 1024
-        
-        # Structure propre pour dataset
-        result = {
-            "image_base64": image_base64,
-            "compressed_size": compressed_size,
-            "file_size_kb": round(file_size_kb, 1),
-            "format": "PNG",
-            "quality": quality
-        }
-        
-        # Nettoyage
-        dataset_image.close()
-        buffer.close()
-        
-        return result
-        
-    except Exception as e:
-        print(f"❌ Erreur préparation image: {e}")
-        return None
-
-def recognize_number_fast_with_image(image_dict: dict | np.ndarray | Image.Image | None) -> tuple[str, Image.Image | None, dict | None]:
-    """OCR avec EasyOCR uniquement (rapide et efficace)"""
-    if image_dict is None:
-        print("  ❌ Image manquante")
-        return "0", None, None
-        
-    if easyocr_reader is None:
-        print("  ❌ EasyOCR non initialisé")
-        return "0", None, None
-
-    try:
-        print("  🔄 Début OCR EasyOCR...")
-        start_time = time.time()
-        
-        # Optimiser image
-        print("  📐 Optimisation image...")
-        opt_start = time.time()
-        optimized_image = optimize_image_for_ocr(image_dict)
-        if optimized_image is None:
-            print("  ❌ Échec optimisation image")
-            return "0", None, None
-        print(f"  ✅ Image optimisée en {time.time() - opt_start:.1f}s")
-
-        # EasyOCR - simple et rapide
-        print("  ⚡ Lancement EasyOCR...")
-        easy_start = time.time()
-        
-        # Convertir PIL vers numpy pour EasyOCR
-        img_array = np.array(optimized_image)
-        results = easyocr_reader.readtext(img_array, detail=0, paragraph=False)
-        
-        if results:
-            # Extraire les chiffres de tous les résultats
-            all_text = ' '.join(str(r) for r in results)
-            cleaned_result = ''.join(filter(str.isdigit, all_text))
-            
-            # Validation longueur
-            if cleaned_result and len(cleaned_result) <= 4:
-                final_result = cleaned_result
-            else:
-                # Si trop long, prendre les premiers chiffres
-                final_result = cleaned_result[:4] if cleaned_result else "0"
-        else:
-            final_result = "0"
-        
-        print(f"  ✅ EasyOCR en {time.time() - easy_start:.1f}s → '{final_result}'")
-        
-        # Préparer pour dataset
-        print("  📦 Préparation dataset...")
-        dataset_start = time.time()
-        dataset_image_data = prepare_image_for_dataset(optimized_image)
-        print(f"  ✅ Dataset prep en {time.time() - dataset_start:.1f}s")
-        
-        total_time = time.time() - start_time
-        print(f"  🏁 OCR total: {total_time:.1f}s")
-        
-        return final_result, optimized_image, dataset_image_data
-
-    except Exception as e:
-        print(f"❌ Erreur OCR EasyOCR: {e}")
-        import traceback
-        traceback.print_exc()
-        return "0", None, None
-
-def recognize_number_fast(image_dict: dict | np.ndarray | Image.Image | None) -> tuple[str, Image.Image | None]:
-    """Version rapide standard pour calculs avec EasyOCR"""
-    result, optimized_image, _ = recognize_number_fast_with_image(image_dict)
-    return result, optimized_image
-
-def recognize_number(image_dict: dict | np.ndarray | Image.Image | None) -> str:
-    """Interface standard pour reconnaissance de calculs avec EasyOCR"""
-    result, _ = recognize_number_fast(image_dict)
-    return result
-
-def create_thumbnail_fast(optimized_image: Image.Image | None, size: tuple[int, int] = (40, 40)) -> str:
-    """Création miniature rapide pour calculs"""
-    try:
-        if optimized_image is None:
-            return "📝"
-            
-        thumbnail = optimized_image.copy()
-        thumbnail.thumbnail(size, Image.Resampling.LANCZOS)
-        
-        buffer = BytesIO()
-        thumbnail.save(buffer, format='PNG', optimize=True, quality=70)
-        img_str = base64.b64encode(buffer.getvalue()).decode()
-        
-        thumbnail.close()
-        buffer.close()
-        
-        return f'<img src="data:image/png;base64,{img_str}" width="{size[0]}" height="{size[1]}" style="border: 1px solid #ccc; border-radius: 3px;" alt="Réponse calcul">'
-        
-    except Exception:
-        return "📝"
-
-# Fonction utilitaire pour fine-tuning calculs
-def decode_image_from_dataset(base64_string: str) -> Image.Image | None:
-    """Décode une image depuis le dataset pour fine-tuning calculs avec EasyOCR"""
-    try:
-        image_bytes = base64.b64decode(base64_string)
-        image = Image.open(BytesIO(image_bytes))
-        return image
-    except Exception as e:
-        print(f"Erreur décodage calcul: {e}")
-        return None
-
-# Fonctions d'analyse pour différents types de calculs
-def analyze_calculation_complexity(operand_a: int, operand_b: int, operation: str) -> dict:
-    """Analyse la complexité d'un calcul pour le dataset"""
-    complexity_score = 0
-    
-    if operation == "×":
-        complexity_score = max(operand_a, operand_b)
-    elif operation == "+":
-        complexity_score = (operand_a + operand_b) / 20
-    elif operation == "-":
-        complexity_score = max(operand_a, operand_b) / 10
-    elif operation == "÷":
-        complexity_score = operand_a / 10
-    
-    return {
-        "complexity_score": round(complexity_score, 2),
-        "difficulty_category": "easy" if complexity_score < 5 else "medium" if complexity_score < 10 else "hard"
-    }