Update app.py

app.py

@@ -85,18 +85,22 @@ def analizar_manipulacion(imagen, metadatos):
     return manipulada, razones
 
 
+
 def realizar_ela(imagen):
-    """Realiza ELA con parámetros automáticos optimizados y salida en BLANCO sobre fondo gris oscuro."""
+    """Realiza ELA con los parámetros y algoritmo exactos del código JavaScript, valores por defecto."""
     try:
+        # Convertir imagen a array numpy y a BGR para OpenCV
         img_np = np.array(imagen.convert("RGB"))
         img_cv = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
 
-        # Parámetros automáticos optimizados
-        quality = 95
-        scale = 47
-        umbral = 25
-        
-        # Guardar y recargar con compresión
+        # ✅ Parámetros por defecto del código JS
+        quality = 95          # Calidad JPG (0-100)
+        noise_level = 3       # Amplitud del ruido (1-30)
+        error_scale = 57 / 100.0  # Escala de error (0-100 → 0.0-1.0)
+        brightness_pct = 100  # Brillo (0-150%)
+        equalize_histogram = False  # Por defecto desactivado
+
+        # Guardar como JPG con calidad especificada
         temp_path = "/tmp/temp_image.jpg"
         cv2.imwrite(temp_path, img_cv, [cv2.IMWRITE_JPEG_QUALITY, quality])
         img_comprimida = cv2.imread(temp_path)
@@ -104,31 +108,42 @@ def realizar_ela(imagen):
             raise ValueError("Error al leer la imagen comprimida")
 
         # Calcular diferencia absoluta
-        diferencia = cv2.absdiff(img_cv, img_comprimida)
-        ela_imagen = scale * diferencia.astype(np.float32)
+        diferencia = cv2.absdiff(img_cv.astype(np.float32), img_comprimida.astype(np.float32))
 
-        # Normalizar y convertir a uint8
-        ela_imagen = cv2.normalize(ela_imagen, None, 0, 255, cv2.NORM_MINMAX).astype(np.uint8)
-        ela_imagen = cv2.GaussianBlur(ela_imagen, (3, 3), 0)
+        # Aplicar "noiseLevel" y "errorScale" como en el código JS
+        # En JS: diff = Math.max(diffR, diffG, diffB) * errorScale * 20;
+        # Y cada canal se multiplica por (noiseLevel / 10)
+        scaled_diff = diferencia * (noise_level / 10.0) * error_scale * 20.0
 
-        # Convertir a escala de grises
-        ela_gray = cv2.cvtColor(ela_imagen, cv2.COLOR_BGR2GRAY)
+        # Limitar valores a 0-255 y convertir a uint8
+        scaled_diff = np.clip(scaled_diff, 0, 255).astype(np.uint8)
 
-        # Crear máscara binaria
-        _, mask = cv2.threshold(ela_gray, umbral, 255, cv2.THRESH_BINARY)
+        # Crear máscara: áreas con error significativo (simulando elaData.data[i + 3] > 0)
+        gray_diff = cv2.cvtColor(scaled_diff, cv2.COLOR_BGR2GRAY)
+        _, mask = cv2.threshold(gray_diff, 30, 255, cv2.THRESH_BINARY)  # Umbral arbitrario para "diff > 0.3"
         mask = mask.astype(np.uint8)
 
-        # ✅ ¡ESTO ES LO ÚNICO QUE CAMBIAMOS!
-        # Áreas detectadas: BLANCO PURO
-        ela_color = cv2.cvtColor(ela_gray, cv2.COLOR_GRAY2BGR)  # Convertir gris → BGR
-        ela_color[mask > 0] = [255, 255, 255]  # Blanco donde hay error
+        # ✅ Aplicar ecualización de histograma si estuviera activada (aunque por defecto es False)
+        if equalize_histogram:
+            # Convertir a escala de grises, ecualizar, y volver a BGR
+            gray = cv2.cvtColor(scaled_diff, cv2.COLOR_BGR2GRAY)
+            gray_eq = cv2.equalizeHist(gray)
+            scaled_diff = cv2.cvtColor(gray_eq, cv2.COLOR_GRAY2BGR)
+
+        # ✅ Aplicar brillo (brightness)
+        brightness_factor = min(1.5, brightness_pct / 100.0)
+        scaled_diff = cv2.convertScaleAbs(scaled_diff, alpha=brightness_factor, beta=0)
+
+        # ✅ Crear imagen final: fondo negro, áreas detectadas en blanco/amarillo
+        # Convertimos la diferencia escalada a una imagen en color
+        ela_color = scaled_diff.copy()
 
         # Fondo: imagen original en escala de grises oscurecida
         img_gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY)
         img_gray = cv2.cvtColor(img_gray, cv2.COLOR_GRAY2BGR)
-        img_gray = cv2.convertScaleAbs(img_gray, alpha=0.5, beta=0)
+        img_gray = cv2.convertScaleAbs(img_gray, alpha=0.5, beta=0)  # Fondo oscuro
 
-        # Combinar: fondo gris + áreas blancas
+        # Combinar: donde hay máscara, mostrar color; donde no, fondo gris
         result = np.where(mask[..., None] > 0, ela_color, img_gray)
 
         os.remove(temp_path)
@@ -142,6 +157,9 @@ def realizar_ela(imagen):
 
 
 
+
+
+
 def procesar_imagen(archivo_imagen):
     """Procesa la imagen y devuelve ZIP + texto de análisis + imagen ELA + URL de Google Maps (si aplica)."""
     try: