First implementation

README_forensic_graphology.md

@@ -0,0 +1,33 @@
+# Forensic Graphology Application
+
+This application provides tools for forensic graphology analysis, including signature comparison, font analysis, ink recognition, and document measurement.
+
+## Features
+
+- Image preprocessing and enhancement
+- Signature comparison and verification
+- Font and ink analysis
+- Document measurement and profiling
+- Machine learning for anomaly detection
+- RAG system for document consultation
+
+## How to run
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+## Deployment on Hugging Face Spaces
+
+This application is designed to be deployed on Hugging Face Spaces.
+
+title: Forensic Graphology Application
+emoji: 🔍
+colorFrom: indigo
+colorTo: purple
+sdk: gradio
+sdk_version: 5.22.0
+app_file: app.py
+pinned: false
+license: mit

app.py

@@ -0,0 +1,807 @@
+import os
+import gradio as gr
+import numpy as np
+import cv2
+import matplotlib.pyplot as plt
+import tempfile
+from PIL import Image
+import torch
+import time
+import json
+
+# Importa i moduli dell'applicazione
+from src.preprocessing import ImagePreprocessor
+from src.signature_analysis import SignatureAnalyzer
+from src.font_analysis import FontAnalyzer
+from src.measurement import MeasurementTool
+from src.image_enhancer import ImageEnhancer
+from src.ml_models import SignatureFeatureExtractor, AnomalyDetector, SignatureVerifier
+from src.rag_system import DocumentProcessor, VectorStore, RAGSystem
+
+# Definisci le directory di lavoro
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+UPLOAD_DIR = os.path.join(BASE_DIR, "uploads")
+RESULTS_DIR = os.path.join(BASE_DIR, "results")
+MODELS_DIR = os.path.join(BASE_DIR, "models")
+VECTOR_STORE_DIR = os.path.join(BASE_DIR, "vector_store")
+
+# Crea le directory se non esistono
+os.makedirs(UPLOAD_DIR, exist_ok=True)
+os.makedirs(RESULTS_DIR, exist_ok=True)
+os.makedirs(MODELS_DIR, exist_ok=True)
+os.makedirs(VECTOR_STORE_DIR, exist_ok=True)
+
+# Inizializza i componenti dell'applicazione
+preprocessor = ImagePreprocessor()
+signature_analyzer = SignatureAnalyzer()
+font_analyzer = FontAnalyzer()
+measurement_tool = MeasurementTool()
+image_enhancer = ImageEnhancer()
+
+# Inizializza il sistema RAG
+rag_system = RAGSystem(
+    upload_dir=UPLOAD_DIR,
+    vector_store_dir=VECTOR_STORE_DIR,
+    use_local_model=True,
+    model_name="google/flan-t5-small"
+)
+
+# Inizializza i modelli di machine learning
+# Nota: questi verranno caricati solo quando necessario
+anomaly_detector = None
+signature_verifier = None
+
+# Funzione per salvare un'immagine temporanea
+def save_temp_image(image):
+    if image is None:
+        return None
+    
+    # Crea un file temporaneo
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".png", dir=UPLOAD_DIR)
+    temp_path = temp_file.name
+    temp_file.close()
+    
+    # Salva l'immagine
+    if isinstance(image, np.ndarray):
+        cv2.imwrite(temp_path, image)
+    elif isinstance(image, Image.Image):
+        image.save(temp_path)
+    
+    return temp_path
+
+# Funzione per convertire una figura matplotlib in un'immagine
+def fig_to_image(fig):
+    # Salva la figura in un file temporaneo
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix=".png", dir=RESULTS_DIR)
+    temp_path = temp_file.name
+    temp_file.close()
+    
+    # Salva la figura
+    fig.savefig(temp_path, dpi=300, bbox_inches='tight')
+    plt.close(fig)
+    
+    # Carica l'immagine
+    image = cv2.imread(temp_path)
+    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+    
+    return image, temp_path
+
+# Funzione per pre-elaborare un'immagine
+def preprocess_image(image):
+    if image is None:
+        return None, "Nessuna immagine fornita."
+    
+    try:
+        # Salva l'immagine temporaneamente
+        temp_path = save_temp_image(image)
+        
+        # Pre-elabora l'immagine
+        processed = preprocessor.preprocess_signature(temp_path)
+        
+        # Crea un'immagine di output con tutte le fasi di pre-elaborazione
+        h, w = processed['original'].shape[:2]
+        output = np.zeros((h * 2, w * 3, 3), dtype=np.uint8)
+        
+        # Converti le immagini in RGB se necessario
+        original_rgb = cv2.cvtColor(processed['original'], cv2.COLOR_BGR2RGB)
+        
+        # Converti le immagini in scala di grigi in RGB
+        grayscale_rgb = cv2.cvtColor(processed['grayscale'], cv2.COLOR_GRAY2RGB)
+        normalized_rgb = cv2.cvtColor(processed['normalized'], cv2.COLOR_GRAY2RGB)
+        denoised_rgb = cv2.cvtColor(processed['denoised'], cv2.COLOR_GRAY2RGB)
+        binary_rgb = cv2.cvtColor(processed['binary'], cv2.COLOR_GRAY2RGB)
+        
+        # Ridimensiona le immagini se necessario
+        original_resized = cv2.resize(original_rgb, (w, h))
+        grayscale_resized = cv2.resize(grayscale_rgb, (w, h))
+        normalized_resized = cv2.resize(normalized_rgb, (w, h))
+        denoised_resized = cv2.resize(denoised_rgb, (w, h))
+        binary_resized = cv2.resize(binary_rgb, (w, h))
+        
+        # Inserisci le immagini nell'output
+        output[0:h, 0:w] = original_resized
+        output[0:h, w:2*w] = grayscale_resized
+        output[0:h, 2*w:3*w] = normalized_resized
+        output[h:2*h, 0:w] = denoised_resized
+        output[h:2*h, w:2*w] = binary_resized
+        
+        # Aggiungi etichette
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        cv2.putText(output, "Originale", (10, 30), font, 1, (255, 255, 255), 2)
+        cv2.putText(output, "Scala di Grigi", (w + 10, 30), font, 1, (255, 255, 255), 2)
+        cv2.putText(output, "Normalizzata", (2*w + 10, 30), font, 1, (255, 255, 255), 2)
+        cv2.putText(output, "Denoised", (10, h + 30), font, 1, (255, 255, 255), 2)
+        cv2.putText(output, "Binaria", (w + 10, h + 30), font, 1, (255, 255, 255), 2)
+        
+        # Salva l'immagine di output
+        output_path = os.path.join(RESULTS_DIR, f"preprocessed_{os.path.basename(temp_path)}")
+        cv2.imwrite(output_path, cv2.cvtColor(output, cv2.COLOR_RGB2BGR))
+        
+        return output, f"Pre-elaborazione completata. Risultati salvati in {output_path}"
+    except Exception as e:
+        return None, f"Errore durante la pre-elaborazione: {str(e)}"
+
+# Funzione per confrontare due firme
+def compare_signatures(image1, image2):
+    if image1 is None or image2 is None:
+        return None, "Fornire entrambe le immagini delle firme."
+    
+    try:
+        # Salva le immagini temporaneamente
+        temp_path1 = save_temp_image(image1)
+        temp_path2 = save_temp_image(image2)
+        
+        # Confronta le firme
+        comparison_result = signature_analyzer.compare_signatures(temp_path1, temp_path2)
+        
+        # Visualizza il confronto
+        fig = signature_analyzer.visualize_comparison(comparison_result)
+        
+        # Converti la figura in un'immagine
+        output_image, output_path = fig_to_image(fig)
+        
+        # Genera un report testuale
+        report = signature_analyzer.generate_comparison_report(comparison_result)
+        
+        # Salva il report
+        report_path = os.path.join(RESULTS_DIR, f"comparison_report_{int(time.time())}.txt")
+        with open(report_path, 'w') as f:
+            f.write(report)
+        
+        return output_image, f"Confronto completato. Punteggio di similarità: {comparison_result['combined_score']:.2f}%\n\n{report}"
+    except Exception as e:
+        return None, f"Errore durante il confronto delle firme: {str(e)}"
+
+# Funzione per analizzare il font e l'inchiostro
+def analyze_font_and_ink(image):
+    if image is None:
+        return None, "Nessuna immagine fornita."
+    
+    try:
+        # Salva l'immagine temporaneamente
+        temp_path = save_temp_image(image)
+        
+        # Carica l'immagine
+        img = preprocessor.load_image(temp_path)
+        
+        # Rileva le regioni di testo
+        text_regions = font_analyzer.detect_text_regions(img)
+        
+        # Estrai il testo
+        text_result = font_analyzer.extract_text(img, text_regions)
+        
+        # Analizza il font
+        font_result = font_analyzer.analyze_font(img, text_regions)
+        
+        # Analizza l'inchiostro
+        ink_result = font_analyzer.analyze_ink(img)
+        
+        # Crea un'immagine di output
+        output = img.copy()
+        
+        # Disegna i rettangoli delle regioni di testo
+        for i, (x, y, w, h) in enumerate(text_regions):
+            cv2.rectangle(output, (x, y), (x + w, y + h), (0, 255, 0), 2)
+            cv2.putText(output, f"Testo {i+1}", (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+        
+        # Converti in RGB per la visualizzazione
+        output_rgb = cv2.cvtColor(output, cv2.COLOR_BGR2RGB)
+        
+        # Prepara il report
+        report = "ANALISI DEL FONT E DELL'INCHIOSTRO\n"
+        report += "=" * 50 + "\n\n"
+        
+        # Aggiungi il testo estratto
+        report += "TESTO ESTRATTO:\n"
+        report += text_result['full_text'] + "\n\n"
+        
+        # Aggiungi l'analisi del font
+        report += "ANALISI DEL FONT:\n"
+        for i, region in enumerate(font_result['regions']):
+            font_info = region['font_info']
+            report += f"Regione {i+1}:\n"
+            report += f"- Tipo: {'Serif' if font_info['is_serif'] else 'Sans-serif'}\n"
+            report += f"- Monospaced: {'Sì' if font_info['is_monospaced'] else 'No'}\n"
+            report += f"- Grassetto: {'Sì' if font_info['is_bold'] else 'No'}\n"
+            report += f"- Corsivo: {'Sì' if font_info['is_italic'] else 'No'}\n"
+            report += f"- Dimensione stimata: {font_info['font_size']:.1f} pt\n"
+            report += f"- Confidenza: {font_info['confidence']:.1f}%\n"
+            report += f"- Font possibili: {', '.join(font_info['possible_fonts'])}\n\n"
+        
+        # Aggiungi l'analisi dell'inchiostro
+        report += "ANALISI DELL'INCHIOSTRO:\n"
+        report += f"- Tipo: {ink_result['ink_type']}\n"
+        report += f"- Colore: {ink_result['ink_color']}\n"
+        report += f"- Stampato: {'Sì' if ink_result['is_printed'] else 'No'}\n"
+        report += f"- Confidenza: {ink_result['confidence']:.1f}%\n\n"
+        
+        report += "DETTAGLI TECNICI:\n"
+        report += f"- Tonalità media (H): {ink_result['details']['hue_mean']:.1f}\n"
+        report += f"- Saturazione media (S): {ink_result['details']['saturation_mean']:.1f}\n"
+        report += f"- Valore medio (V): {ink_result['details']['value_mean']:.1f}\n"
+        report += f"- Deviazione standard tonalità: {ink_result['details']['hue_std']:.1f}\n"
+        report += f"- Deviazione standard saturazione: {ink_result['details']['saturation_std']:.1f}\n"
+        report += f"- Deviazione standard valore: {ink_result['details']['value_std']:.1f}\n"
+        report += f"- Copertura inchiostro: {ink_result['details']['ink_coverage']*100:.1f}%\n"
+        
+        # Salva il report
+        report_path = os.path.join(RESULTS_DIR, f"font_ink_analysis_{int(time.time())}.txt")
+        with open(report_path, 'w') as f:
+            f.write(report)
+        
+        return output_rgb, report
+    except Exception as e:
+        return None, f"Errore durante l'analisi del font e dell'inchiostro: {str(e)}"
+
+# Funzione per misurare e profilare un documento
+def measure_document(image):
+    if image is None:
+        return None, "Nessuna immagine fornita."
+    
+    try:
+        # Salva l'immagine temporaneamente
+        temp_path = save_temp_image(image)
+        
+        # Carica l'immagine
+        img = preprocessor.load_image(temp_path)
+        
+        # Genera il report di misurazione
+        measurements = measurement_tool.generate_measurement_report(img)
+        
+        # Visualizza le misurazioni
+        fig = measurement_tool.visualize_measurements(img, measurements)
+        
+        # Converti la figura in un'immagine
+        output_image, output_path = fig_to_image(fig)
+        
+        # Crea un righello digitale
+        ruler_image = measurement_tool.create_digital_ruler(img)
+        ruler_path = os.path.join(RESULTS_DIR, f"ruler_{os.path.basename(temp_path)}")
+        cv2.imwrite(ruler_path, ruler_image)
+        
+        # Prepara il report
+        report = "REPORT DI MISURAZIONE DEL DOCUMENTO\n"
+        report += "=" * 50 + "\n\n"
+        
+        # Aggiungi le misurazioni delle linee
+        report += "SPAZIO TRA LE LINEE:\n"
+        report += f"- Numero di linee: {measurements['line_spacing']['line_count']}\n"
+        report += f"- Spazio medio: {measurements['line_spacing']['average_spacing']:.1f} pixel\n"
+        report += f"- Deviazione standard: {measurements['line_spacing']['spacing_std']:.1f} pixel\n\n"
+        
+        # Aggiungi le misurazioni delle parole
+        report += "SPAZIO TRA LE PAROLE:\n"
+        report += f"- Numero di parole: {measurements['word_spacing']['word_count']}\n"
+        report += f"- Spazio medio: {measurements['word_spacing']['average_spacing']:.1f} pixel\n"
+        report += f"- Deviazione standard: {measurements['word_spacing']['spacing_std']:.1f} pixel\n\n"
+        
+        # Aggiungi i margini
+        report += "MARGINI:\n"
+        report += f"- Superiore: {measurements['margins']['top']} pixel\n"
+        report += f"- Inferiore: {measurements['margins']['bottom']} pixel\n"
+        report += f"- Sinistro: {measurements['margins']['left']} pixel\n"
+        report += f"- Destro: {measurements['margins']['right']} pixel\n\n"
+        
+        # Aggiungi l'inclinazione dei caratteri
+        report += "INCLINAZIONE DEI CARATTERI:\n"
+        report += f"- Inclinazione media: {measurements['character_slant']['average_slant']:.1f} gradi\n"
+        report += f"- Deviazione standard: {measurements['character_slant']['slant_std']:.1f} gradi\n\n"
+        
+        # Aggiungi il profilo di pressione
+        report += "PROFILO DI PRESSIONE:\n"
+        report += f"- Pressione media: {measurements['pressure_profile']['average_pressure']:.1f}\n"
+        report += f"- Deviazione standard: {measurements['pressure_profile']['pressure_std']:.1f}\n"
+        
+        # Salva il report
+        report_path = os.path.join(RESULTS_DIR, f"measurement_report_{int(time.time())}.txt")
+        with open(report_path, 'w') as f:
+            f.write(report)
+        
+        return output_image, report
+    except Exception as e:
+        return None, f"Errore durante la misurazione del documento: {str(e)}"
+
+# Funzione per migliorare un'immagine
+def enhance_image(image, enhancement_type):
+    if image is None:
+        return None, "Nessuna immagine fornita."
+    
+    try:
+        # Salva l'immagine temporaneamente
+        temp_path = save_temp_image(image)
+        
+        # Carica l'immagine
+        img = preprocessor.load_image(temp_path)
+        
+        # Applica il miglioramento selezionato
+        if enhancement_type == "contrast":
+            enhanced = image_enhancer.enhance_contrast(img, method='clahe')
+            title = "Miglioramento del Contrasto"
+        elif enhancement_type == "sharpen":
+            enhanced = image_enhancer.sharpen_image(img, strength=1.5)
+            title = "Sharpening dell'Immagine"
+        elif enhancement_type == "edges":
+            enhanced = image_enhancer.apply_edge_detection(img, method='canny')
+            title = "Rilevamento dei Bordi"
+        elif enhancement_type == "pressure":
+            enhanced = image_enhancer.highlight_pressure_points(img)
+            title = "Evidenziazione Punti di Pressione"
+        elif enhancement_type == "emboss":
+            enhanced = image_enhancer.apply_emboss_effect(img)
+            title = "Effetto Rilievo"
+        elif enhancement_type == "heatmap":
+            enhanced = image_enhancer.create_signature_heatmap(img)
+            title = "Mappa di Calore della Firma"
+        elif enhancement_type == "all":
+            # Applica tutti i miglioramenti
+            enhancements = image_enhancer.enhance_signature(img)
+            
+            # Crea un'immagine di output con tutti i miglioramenti
+            h, w = enhancements['original'].shape[:2]
+            output = np.zeros((h * 2, w * 4, 3), dtype=np.uint8)
+            
+            # Converti le immagini in RGB se necessario
+            original_rgb = cv2.cvtColor(enhancements['original'], cv2.COLOR_BGR2RGB)
+            
+            # Converti le immagini in scala di grigi in RGB
+            grayscale_rgb = cv2.cvtColor(enhancements['grayscale'], cv2.COLOR_GRAY2RGB)
+            contrast_rgb = cv2.cvtColor(enhancements['contrast_enhanced'], cv2.COLOR_GRAY2RGB)
+            sharpened_rgb = cv2.cvtColor(enhancements['sharpened'], cv2.COLOR_GRAY2RGB)
+            edges_rgb = cv2.cvtColor(enhancements['edges'], cv2.COLOR_GRAY2RGB)
+            embossed_rgb = cv2.cvtColor(enhancements['embossed'], cv2.COLOR_GRAY2RGB)
+            
+            # Inserisci le immagini nell'output
+            output[0:h, 0:w] = original_rgb
+            output[0:h, w:2*w] = grayscale_rgb
+            output[0:h, 2*w:3*w] = contrast_rgb
+            output[0:h, 3*w:4*w] = sharpened_rgb
+            output[h:2*h, 0:w] = edges_rgb
+            output[h:2*h, w:2*w] = embossed_rgb
+            output[h:2*h, 2*w:3*w] = enhancements['pressure_points']
+            output[h:2*h, 3*w:4*w] = enhancements['heatmap']
+            
+            # Aggiungi etichette
+            font = cv2.FONT_HERSHEY_SIMPLEX
+            cv2.putText(output, "Originale", (10, 30), font, 1, (255, 255, 255), 2)
+            cv2.putText(output, "Scala di Grigi", (w + 10, 30), font, 1, (255, 255, 255), 2)
+            cv2.putText(output, "Contrasto", (2*w + 10, 30), font, 1, (255, 255, 255), 2)
+            cv2.putText(output, "Sharpening", (3*w + 10, 30), font, 1, (255, 255, 255), 2)
+            cv2.putText(output, "Bordi", (10, h + 30), font, 1, (255, 255, 255), 2)
+            cv2.putText(output, "Rilievo", (w + 10, h + 30), font, 1, (255, 255, 255), 2)
+            cv2.putText(output, "Punti di Pressione", (2*w + 10, h + 30), font, 1, (255, 255, 255), 2)
+            cv2.putText(output, "Mappa di Calore", (3*w + 10, h + 30), font, 1, (255, 255, 255), 2)
+            
+            enhanced = output
+            title = "Tutti i Miglioramenti"
+        else:
+            return None, f"Tipo di miglioramento non supportato: {enhancement_type}"
+        
+        # Salva l'immagine migliorata
+        output_path = os.path.join(RESULTS_DIR, f"{enhancement_type}_{os.path.basename(temp_path)}")
+        
+        # Converti in BGR per il salvataggio se necessario
+        if len(enhanced.shape) == 3 and enhanced.shape[2] == 3:
+            cv2.imwrite(output_path, cv2.cvtColor(enhanced, cv2.COLOR_RGB2BGR))
+        else:
+            cv2.imwrite(output_path, enhanced)
+        
+        # Converti in RGB per la visualizzazione se necessario
+        if len(enhanced.shape) == 2:
+            enhanced_rgb = cv2.cvtColor(enhanced, cv2.COLOR_GRAY2RGB)
+        elif enhanced.shape[2] == 3:
+            enhanced_rgb = enhanced
+        else:
+            enhanced_rgb = enhanced
+        
+        return enhanced_rgb, f"{title} completato. Risultato salvato in {output_path}"
+    except Exception as e:
+        return None, f"Errore durante il miglioramento dell'immagine: {str(e)}"
+
+# Funzione per rilevare anomalie in una firma
+def detect_anomalies(image, model_path=None):
+    global anomaly_detector
+    
+    if image is None:
+        return "Nessuna immagine fornita."
+    
+    try:
+        # Salva l'immagine temporaneamente
+        temp_path = save_temp_image(image)
+        
+        # Inizializza il rilevatore di anomalie se non è già stato fatto
+        if anomaly_detector is None:
+            anomaly_detector = AnomalyDetector()
+            
+            # Carica il modello se specificato
+            if model_path and os.path.exists(model_path):
+                anomaly_detector.load_model(model_path)
+            else:
+                # Cerca un modello nella directory dei modelli
+                model_files = [f for f in os.listdir(MODELS_DIR) if f.endswith('.joblib') and 'anomaly' in f]
+                if model_files:
+                    model_path = os.path.join(MODELS_DIR, model_files[0])
+                    anomaly_detector.load_model(model_path)
+                else:
+                    return "Nessun modello di rilevamento anomalie trovato. Addestrare un modello prima di utilizzare questa funzione."
+        
+        # Estrai caratteristiche dalla firma
+        feature_extractor = SignatureFeatureExtractor()
+        features = feature_extractor.extract_features(temp_path)
+        
+        # Rileva anomalie
+        result = anomaly_detector.predict(features=features)
+        
+        # Prepara il report
+        report = "RILEVAMENTO ANOMALIE NELLA FIRMA\n"
+        report += "=" * 50 + "\n\n"
+        
+        report += f"RISULTATO: {'ANOMALIA RILEVATA' if result['is_anomaly'] else 'FIRMA NORMALE'}\n\n"
+        
+        report += f"Punteggio di anomalia: {result['anomaly_score']:.4f}\n"
+        report += f"Confidenza: {result['confidence']:.2f}%\n\n"
+        
+        report += "INTERPRETAZIONE:\n"
+        if result['is_anomaly']:
+            report += "La firma presenta caratteristiche anomale rispetto al modello di riferimento.\n"
+            report += "Potrebbe trattarsi di una firma falsa o di una variazione significativa rispetto alle firme autentiche.\n"
+        else:
+            report += "La firma presenta caratteristiche coerenti con il modello di riferimento.\n"
+            report += "È probabile che si tratti di una firma autentica.\n"
+        
+        report += "\nNOTA: Questo risultato è basato su un modello statistico e deve essere interpretato da un esperto di grafologia forense."
+        
+        return report
+    except Exception as e:
+        return f"Errore durante il rilevamento delle anomalie: {str(e)}"
+
+# Funzione per verificare due firme
+def verify_signatures(image1, image2, model_path=None):
+    global signature_verifier
+    
+    if image1 is None or image2 is None:
+        return "Fornire entrambe le immagini delle firme."
+    
+    try:
+        # Salva le immagini temporaneamente
+        temp_path1 = save_temp_image(image1)
+        temp_path2 = save_temp_image(image2)
+        
+        # Inizializza il verificatore di firme se non è già stato fatto
+        if signature_verifier is None:
+            signature_verifier = SignatureVerifier()
+            
+            # Carica il modello se specificato
+            if model_path and os.path.exists(model_path):
+                signature_verifier.load_model(model_path)
+            else:
+                # Cerca un modello nella directory dei modelli
+                model_files = [f for f in os.listdir(MODELS_DIR) if f.endswith('.pth') and 'verifier' in f]
+                if model_files:
+                    model_path = os.path.join(MODELS_DIR, model_files[0])
+                    signature_verifier.load_model(model_path)
+                else:
+                    return "Nessun modello di verifica firme trovato. Addestrare un modello prima di utilizzare questa funzione."
+        
+        # Verifica le firme
+        result = signature_verifier.verify(temp_path1, temp_path2)
+        
+        # Prepara il report
+        report = "VERIFICA DELLE FIRME\n"
+        report += "=" * 50 + "\n\n"
+        
+        report += f"RISULTATO: {'STESSA PERSONA' if result['is_same_person'] else 'PERSONE DIVERSE'}\n\n"
+        
+        report += f"Probabilità: {result['probability']:.4f}\n"
+        report += f"Confidenza: {result['confidence']:.2f}%\n\n"
+        
+        report += "INTERPRETAZIONE:\n"
+        if result['is_same_person']:
+            report += "Le due firme sono probabilmente della stessa persona.\n"
+            report += f"Il modello ha una confidenza del {result['confidence']:.2f}% in questa valutazione.\n"
+        else:
+            report += "Le due firme sono probabilmente di persone diverse.\n"
+            report += f"Il modello ha una confidenza del {result['confidence']:.2f}% in questa valutazione.\n"
+        
+        report += "\nNOTA: Questo risultato è basato su un modello di deep learning e deve essere interpretato da un esperto di grafologia forense."
+        
+        return report
+    except Exception as e:
+        return f"Errore durante la verifica delle firme: {str(e)}"
+
+# Funzione per caricare un documento nel sistema RAG
+def upload_document(file):
+    if file is None:
+        return "Nessun file fornito."
+    
+    try:
+        # Elabora e memorizza il documento
+        result = rag_system.process_and_store_document(file)
+        
+        if result['success']:
+            return f"Documento '{result['filename']}' caricato e indicizzato con successo.\n\n" + \
+                   f"ID documento: {result['document_id']}\n" + \
+                   f"Numero di chunk: {result['chunk_count']}"
+        else:
+            return f"Errore durante il caricamento del documento: {result['error']}"
+    except Exception as e:
+        return f"Errore durante il caricamento del documento: {str(e)}"
+
+# Funzione per eseguire una query sul sistema RAG
+def query_rag(query_text):
+    if not query_text:
+        return "Nessuna query fornita."
+    
+    try:
+        # Esegui la query
+        result = rag_system.query(query_text)
+        
+        if result['success']:
+            # Prepara la risposta
+            response = f"RISPOSTA:\n{result['response']}\n\n"
+            
+            # Aggiungi i riferimenti
+            response += "RIFERIMENTI:\n"
+            for ref in result['references']:
+                response += f"[{ref['id']}] {ref['filename']} (chunk {ref['chunk_id']+1}/{ref['chunk_total']})\n"
+                response += f"    Snippet: {ref['snippet']}\n\n"
+            
+            return response
+        else:
+            return f"Errore durante l'esecuzione della query: {result['error']}"
+    except Exception as e:
+        return f"Errore durante l'esecuzione della query: {str(e)}"
+
+# Funzione per ottenere la lista dei documenti nel sistema RAG
+def get_document_list():
+    try:
+        # Ottieni la lista dei documenti
+        documents = rag_system.get_document_list()
+        
+        if not documents:
+            return "Nessun documento trovato nel sistema."
+        
+        # Prepara la risposta
+        response = "DOCUMENTI NEL SISTEMA:\n"
+        response += "=" * 50 + "\n\n"
+        
+        for i, doc in enumerate(documents):
+            response += f"[{i+1}] {doc['filename']}\n"
+            response += f"    ID: {doc['document_id']}\n"
+            response += f"    Numero di chunk: {doc['chunk_total']}\n"
+            response += f"    Data di elaborazione: {doc['processing_date']}\n\n"
+        
+        return response
+    except Exception as e:
+        return f"Errore durante il recupero della lista dei documenti: {str(e)}"
+
+# Funzione per eliminare un documento dal sistema RAG
+def delete_document(document_id):
+    if not document_id:
+        return "Nessun ID documento fornito."
+    
+    try:
+        # Elimina il documento
+        result = rag_system.vector_store.delete_document(document_id)
+        
+        if result['success']:
+            return f"Documento con ID '{document_id}' eliminato con successo."
+        else:
+            return f"Errore durante l'eliminazione del documento: {result['error']}"
+    except Exception as e:
+        return f"Errore durante l'eliminazione del documento: {str(e)}"
+
+# Crea l'interfaccia Gradio
+def create_interface():
+    # Crea i tab per le diverse funzionalità
+    with gr.Blocks(title="Grafologia Forense") as app:
+        gr.Markdown("# Applicazione di Grafologia Forense")
+        gr.Markdown("Questa applicazione fornisce strumenti per l'analisi forense di firme e documenti.")
+        
+        with gr.Tabs():
+            # Tab per la pre-elaborazione delle immagini
+            with gr.Tab("Pre-elaborazione"):
+                with gr.Row():
+                    with gr.Column():
+                        preprocess_input = gr.Image(label="Immagine da pre-elaborare", type="numpy")
+                        preprocess_button = gr.Button("Pre-elabora")
+                    with gr.Column():
+                        preprocess_output = gr.Image(label="Risultato della pre-elaborazione")
+                        preprocess_text = gr.Textbox(label="Output", lines=5)
+                
+                preprocess_button.click(
+                    fn=preprocess_image,
+                    inputs=[preprocess_input],
+                    outputs=[preprocess_output, preprocess_text]
+                )
+            
+            # Tab per la comparazione di firme
+            with gr.Tab("Comparazione Firme"):
+                with gr.Row():
+                    with gr.Column():
+                        compare_input1 = gr.Image(label="Firma 1", type="numpy")
+                        compare_input2 = gr.Image(label="Firma 2", type="numpy")
+                        compare_button = gr.Button("Confronta")
+                    with gr.Column():
+                        compare_output = gr.Image(label="Risultato del confronto")
+                        compare_text = gr.Textbox(label="Report", lines=10)
+                
+                compare_button.click(
+                    fn=compare_signatures,
+                    inputs=[compare_input1, compare_input2],
+                    outputs=[compare_output, compare_text]
+                )
+            
+            # Tab per l'analisi di font e inchiostro
+            with gr.Tab("Analisi Font e Inchiostro"):
+                with gr.Row():
+                    with gr.Column():
+                        font_input = gr.Image(label="Immagine da analizzare", type="numpy")
+                        font_button = gr.Button("Analizza")
+                    with gr.Column():
+                        font_output = gr.Image(label="Regioni di testo rilevate")
+                        font_text = gr.Textbox(label="Report", lines=15)
+                
+                font_button.click(
+                    fn=analyze_font_and_ink,
+                    inputs=[font_input],
+                    outputs=[font_output, font_text]
+                )
+            
+            # Tab per la misurazione e profilazione
+            with gr.Tab("Misurazione e Profilazione"):
+                with gr.Row():
+                    with gr.Column():
+                        measure_input = gr.Image(label="Documento da misurare", type="numpy")
+                        measure_button = gr.Button("Misura")
+                    with gr.Column():
+                        measure_output = gr.Image(label="Risultato della misurazione")
+                        measure_text = gr.Textbox(label="Report", lines=15)
+                
+                measure_button.click(
+                    fn=measure_document,
+                    inputs=[measure_input],
+                    outputs=[measure_output, measure_text]
+                )
+            
+            # Tab per il miglioramento delle immagini
+            with gr.Tab("Miglioramento Immagini"):
+                with gr.Row():
+                    with gr.Column():
+                        enhance_input = gr.Image(label="Immagine da migliorare", type="numpy")
+                        enhance_type = gr.Radio(
+                            label="Tipo di miglioramento",
+                            choices=["contrast", "sharpen", "edges", "pressure", "emboss", "heatmap", "all"],
+                            value="contrast"
+                        )
+                        enhance_button = gr.Button("Migliora")
+                    with gr.Column():
+                        enhance_output = gr.Image(label="Risultato del miglioramento")
+                        enhance_text = gr.Textbox(label="Output", lines=5)
+                
+                enhance_button.click(
+                    fn=enhance_image,
+                    inputs=[enhance_input, enhance_type],
+                    outputs=[enhance_output, enhance_text]
+                )
+            
+            # Tab per il machine learning
+            with gr.Tab("Machine Learning"):
+                with gr.Tabs():
+                    # Subtab per il rilevamento di anomalie
+                    with gr.Tab("Rilevamento Anomalie"):
+                        with gr.Row():
+                            with gr.Column():
+                                anomaly_input = gr.Image(label="Firma da analizzare", type="numpy")
+                                anomaly_button = gr.Button("Rileva Anomalie")
+                            with gr.Column():
+                                anomaly_text = gr.Textbox(label="Report", lines=15)
+                        
+                        anomaly_button.click(
+                            fn=detect_anomalies,
+                            inputs=[anomaly_input],
+                            outputs=[anomaly_text]
+                        )
+                    
+                    # Subtab per la verifica delle firme
+                    with gr.Tab("Verifica Firme"):
+                        with gr.Row():
+                            with gr.Column():
+                                verify_input1 = gr.Image(label="Firma 1", type="numpy")
+                                verify_input2 = gr.Image(label="Firma 2", type="numpy")
+                                verify_button = gr.Button("Verifica")
+                            with gr.Column():
+                                verify_text = gr.Textbox(label="Report", lines=15)
+                        
+                        verify_button.click(
+                            fn=verify_signatures,
+                            inputs=[verify_input1, verify_input2],
+                            outputs=[verify_text]
+                        )
+            
+            # Tab per il sistema RAG
+            with gr.Tab("Sistema RAG"):
+                with gr.Tabs():
+                    # Subtab per il caricamento dei documenti
+                    with gr.Tab("Caricamento Documenti"):
+                        with gr.Row():
+                            with gr.Column():
+                                upload_input = gr.File(label="Documento da caricare")
+                                upload_button = gr.Button("Carica")
+                            with gr.Column():
+                                upload_text = gr.Textbox(label="Output", lines=5)
+                        
+                        upload_button.click(
+                            fn=upload_document,
+                            inputs=[upload_input],
+                            outputs=[upload_text]
+                        )
+                    
+                    # Subtab per le query
+                    with gr.Tab("Query"):
+                        with gr.Row():
+                            with gr.Column():
+                                query_input = gr.Textbox(label="Query", lines=3)
+                                query_button = gr.Button("Esegui Query")
+                            with gr.Column():
+                                query_text = gr.Textbox(label="Risposta", lines=15)
+                        
+                        query_button.click(
+                            fn=query_rag,
+                            inputs=[query_input],
+                            outputs=[query_text]
+                        )
+                    
+                    # Subtab per la gestione dei documenti
+                    with gr.Tab("Gestione Documenti"):
+                        with gr.Row():
+                            with gr.Column():
+                                list_button = gr.Button("Lista Documenti")
+                                delete_input = gr.Textbox(label="ID Documento da eliminare")
+                                delete_button = gr.Button("Elimina Documento")
+                            with gr.Column():
+                                doc_text = gr.Textbox(label="Output", lines=15)
+                        
+                        list_button.click(
+                            fn=get_document_list,
+                            inputs=[],
+                            outputs=[doc_text]
+                        )
+                        
+                        delete_button.click(
+                            fn=delete_document,
+                            inputs=[delete_input],
+                            outputs=[doc_text]
+                        )
+    
+    return app
+
+# Funzione principale
+def main():
+    # Crea l'interfaccia
+    app = create_interface()
+    
+    # Avvia l'applicazione
+    app.launch(share=True)
+
+if __name__ == "__main__":
+    main()

docs/technical_docs.md

@@ -0,0 +1,223 @@
+# Documentazione Tecnica - Applicazione di Grafologia Forense
+
+## Architettura del Sistema
+
+L'applicazione di Grafologia Forense è strutturata in moduli indipendenti che lavorano insieme per fornire un'analisi completa di firme e documenti. L'architettura è basata su Python con un'interfaccia utente Gradio.
+
+### Struttura delle Directory
+
+```
+forensic_graphology/
+├── app.py                 # Punto di ingresso dell'applicazione
+├── requirements.txt       # Dipendenze Python
+├── README.md              # Documentazione generale
+├── hf-space.yaml          # Configurazione per Hugging Face Spaces
+├── src/                   # Codice sorgente
+│   ├── preprocessing.py   # Pre-elaborazione delle immagini
+│   ├── signature_analysis.py # Analisi delle firme
+│   ├── font_analysis.py   # Analisi di font e inchiostro
+│   ├── measurement.py     # Strumenti di misurazione
+│   ├── image_enhancer.py  # Miglioramento delle immagini
+│   ├── ml_models.py       # Modelli di machine learning
+│   └── rag_system.py      # Sistema RAG
+├── models/                # Directory per i modelli addestrati
+├── uploads/               # Directory per i file caricati
+├── results/               # Directory per i risultati generati
+├── vector_store/          # Directory per il vector store
+└── docs/                  # Documentazione
+    ├── user_guide.md      # Guida utente
+    └── technical_docs.md  # Documentazione tecnica
+```
+
+## Moduli Principali
+
+### 1. Preprocessing (preprocessing.py)
+
+Questo modulo gestisce la pre-elaborazione delle immagini di firme e documenti.
+
+**Classi principali:**
+- `ImagePreprocessor`: Classe per la pre-elaborazione delle immagini
+
+**Metodi principali:**
+- `load_image(image_path)`: Carica un'immagine da un percorso
+- `convert_to_grayscale(image)`: Converte un'immagine in scala di grigi
+- `normalize_image(image)`: Normalizza un'immagine
+- `denoise_image(image)`: Riduce il rumore in un'immagine
+- `binarize_image(image)`: Converte un'immagine in bianco e nero
+- `preprocess_signature(image_path)`: Applica tutte le fasi di pre-elaborazione a un'immagine di firma
+
+### 2. Signature Analysis (signature_analysis.py)
+
+Questo modulo fornisce funzionalità per l'analisi e la comparazione di firme.
+
+**Classi principali:**
+- `SignatureAnalyzer`: Classe per l'analisi delle firme
+
+**Metodi principali:**
+- `extract_features_orb(image)`: Estrae caratteristiche ORB da un'immagine
+- `extract_signature_metrics(image)`: Estrae metriche grafometriche da una firma
+- `compare_signatures(image1_path, image2_path)`: Confronta due firme
+- `visualize_comparison(comparison_result)`: Visualizza il risultato del confronto
+- `generate_comparison_report(comparison_result)`: Genera un report testuale del confronto
+
+### 3. Font Analysis (font_analysis.py)
+
+Questo modulo analizza il tipo di font e l'inchiostro utilizzato nei documenti.
+
+**Classi principali:**
+- `FontAnalyzer`: Classe per l'analisi di font e inchiostro
+
+**Metodi principali:**
+- `detect_text_regions(image)`: Rileva le regioni di testo in un'immagine
+- `extract_text(image, regions)`: Estrae il testo dalle regioni rilevate
+- `analyze_font(image, regions)`: Analizza il tipo di font
+- `analyze_ink(image)`: Analizza il tipo di inchiostro
+
+### 4. Measurement (measurement.py)
+
+Questo modulo fornisce strumenti per la misurazione di vari aspetti dei documenti.
+
+**Classi principali:**
+- `MeasurementTool`: Classe per la misurazione dei documenti
+
+**Metodi principali:**
+- `measure_line_spacing(image)`: Misura lo spazio tra le linee
+- `measure_word_spacing(image)`: Misura lo spazio tra le parole
+- `measure_margins(image)`: Misura i margini del documento
+- `measure_character_slant(image)`: Misura l'inclinazione dei caratteri
+- `create_digital_ruler(image)`: Crea un righello digitale
+- `generate_measurement_report(image)`: Genera un report completo di misurazione
+
+### 5. Image Enhancer (image_enhancer.py)
+
+Questo modulo fornisce funzionalità per il miglioramento delle immagini.
+
+**Classi principali:**
+- `ImageEnhancer`: Classe per il miglioramento delle immagini
+
+**Metodi principali:**
+- `enhance_contrast(image, method)`: Migliora il contrasto di un'immagine
+- `sharpen_image(image, kernel_size, strength)`: Applica un filtro di sharpening
+- `apply_edge_detection(image, method)`: Applica un rilevatore di bordi
+- `highlight_pressure_points(image)`: Evidenzia i punti di pressione
+- `apply_emboss_effect(image)`: Applica un effetto di rilievo
+- `create_signature_heatmap(image)`: Crea una mappa di calore della firma
+
+### 6. Machine Learning Models (ml_models.py)
+
+Questo modulo implementa modelli di machine learning per l'analisi delle firme.
+
+**Classi principali:**
+- `SignatureFeatureExtractor`: Estrae caratteristiche dalle firme
+- `AnomalyDetector`: Rileva anomalie nelle firme usando Isolation Forest
+- `SignatureVerifier`: Verifica l'autenticità delle firme usando una rete siamese
+- `SiameseNetwork`: Implementazione della rete neurale siamese
+
+**Metodi principali:**
+- `extract_features(image_path)`: Estrae caratteristiche da un'immagine di firma
+- `fit(signatures_df)`: Addestra il modello di rilevamento anomalie
+- `predict(signature_path)`: Predice se una firma è anomala
+- `verify(image_path1, image_path2)`: Verifica se due firme sono della stessa persona
+
+### 7. RAG System (rag_system.py)
+
+Questo modulo implementa un sistema RAG per la consultazione di documenti.
+
+**Classi principali:**
+- `DocumentProcessor`: Elabora e estrae testo dai documenti
+- `VectorStore`: Gestisce il vector store per il sistema RAG
+- `RAGSystem`: Implementa il sistema RAG completo
+
+**Metodi principali:**
+- `extract_text(file_path)`: Estrae il testo da un documento
+- `process_document(file_path)`: Elabora un documento e lo divide in chunk
+- `add_document(document_info)`: Aggiunge un documento al vector store
+- `search(query, k)`: Cerca documenti simili a una query
+- `query(query_text)`: Esegue una query sul sistema RAG
+
+## Interfaccia Utente (app.py)
+
+L'interfaccia utente è implementata utilizzando Gradio, una libreria Python per la creazione di interfacce web per modelli di machine learning.
+
+**Funzioni principali:**
+- `preprocess_image(image)`: Pre-elabora un'immagine
+- `compare_signatures(image1, image2)`: Confronta due firme
+- `analyze_font_and_ink(image)`: Analizza font e inchiostro
+- `measure_document(image)`: Misura un documento
+- `enhance_image(image, enhancement_type)`: Migliora un'immagine
+- `detect_anomalies(image)`: Rileva anomalie in una firma
+- `verify_signatures(image1, image2)`: Verifica due firme
+- `upload_document(file)`: Carica un documento nel sistema RAG
+- `query_rag(query_text)`: Esegue una query sul sistema RAG
+
+## Dipendenze Principali
+
+- **OpenCV**: Elaborazione delle immagini
+- **NumPy**: Operazioni numeriche
+- **Pandas**: Manipolazione dei dati
+- **Matplotlib**: Visualizzazione
+- **Scikit-learn**: Algoritmi di machine learning
+- **PyTorch**: Deep learning
+- **Gradio**: Interfaccia utente
+- **LangChain**: Framework per il sistema RAG
+- **Sentence-Transformers**: Modelli di embedding
+- **ChromaDB**: Database vettoriale
+- **PyMuPDF, python-docx, python-pptx**: Estrazione di testo da documenti
+- **pytesseract**: OCR per l'estrazione di testo dalle immagini
+
+## Deployment
+
+L'applicazione è progettata per essere deployata su Hugging Face Spaces, una piattaforma per l'hosting di applicazioni di machine learning.
+
+**File di configurazione:**
+- `requirements.txt`: Elenca tutte le dipendenze Python
+- `hf-space.yaml`: Configura l'ambiente Hugging Face Spaces
+- `README.md`: Contiene metadati per Hugging Face Spaces
+
+## Estensione dell'Applicazione
+
+### Aggiungere Nuove Funzionalità
+
+Per aggiungere nuove funzionalità all'applicazione:
+
+1. Creare un nuovo modulo in `src/` o estendere un modulo esistente
+2. Implementare la logica della nuova funzionalità
+3. Aggiungere una nuova funzione in `app.py` che utilizza la nuova funzionalità
+4. Aggiungere un nuovo tab o elemento UI in `create_interface()` in `app.py`
+
+### Addestrare Nuovi Modelli
+
+Per addestrare nuovi modelli di machine learning:
+
+1. Raccogliere un dataset di firme (autentiche e false per il verificatore, solo autentiche per il rilevatore di anomalie)
+2. Utilizzare le classi `AnomalyDetector` o `SignatureVerifier` per addestrare i modelli
+3. Salvare i modelli addestrati nella directory `models/`
+4. Aggiornare l'applicazione per utilizzare i nuovi modelli
+
+## Considerazioni sulla Sicurezza
+
+- L'applicazione non memorizza le immagini caricate a lungo termine
+- I documenti caricati nel sistema RAG sono memorizzati localmente
+- Non vengono utilizzate API esterne per l'elaborazione dei dati
+- Il sistema RAG funziona in modalità di sola ricerca per evitare la necessità di token API
+
+## Limitazioni Tecniche
+
+- L'OCR potrebbe non funzionare correttamente con testi in lingue non latine
+- I modelli di machine learning richiedono un addestramento specifico per casi d'uso particolari
+- L'analisi del font e dell'inchiostro ha una precisione limitata
+- Il sistema RAG funziona in modalità di sola ricerca, senza generazione di risposte AI
+
+## Risoluzione dei Problemi
+
+- **Errori di memoria**: Ridurre la dimensione delle immagini o utilizzare batch più piccoli
+- **Errori di OCR**: Migliorare la qualità delle immagini o utilizzare pre-elaborazione
+- **Prestazioni lente**: Ottimizzare i parametri dei modelli o utilizzare hardware più potente
+
+## Riferimenti
+
+- [OpenCV Documentation](https://docs.opencv.org/)
+- [Scikit-learn Documentation](https://scikit-learn.org/stable/documentation.html)
+- [PyTorch Documentation](https://pytorch.org/docs/stable/index.html)
+- [Gradio Documentation](https://gradio.app/docs/)
+- [LangChain Documentation](https://python.langchain.com/docs/get_started/introduction)

docs/user_guide.md

@@ -0,0 +1,141 @@
+# Guida Utente - Applicazione di Grafologia Forense
+
+## Introduzione
+
+Benvenuti nell'applicazione di Grafologia Forense, uno strumento completo per l'analisi e la verifica di firme e documenti. Questa applicazione combina tecniche di elaborazione delle immagini, machine learning e sistemi di recupero delle informazioni per fornire un'analisi dettagliata di firme e documenti.
+
+## Funzionalità Principali
+
+L'applicazione è organizzata in diverse sezioni, ciascuna dedicata a specifiche funzionalità:
+
+### 1. Pre-elaborazione
+
+Questa sezione permette di caricare e pre-elaborare le immagini di firme e documenti. Il processo di pre-elaborazione include:
+- Conversione in scala di grigi
+- Normalizzazione dell'immagine
+- Riduzione del rumore
+- Binarizzazione
+
+**Come utilizzare:**
+1. Caricare un'immagine utilizzando il pulsante di upload
+2. Cliccare su "Pre-elabora"
+3. Visualizzare i risultati della pre-elaborazione
+
+### 2. Comparazione Firme
+
+Questa sezione permette di confrontare due firme per determinare il loro grado di similarità. L'analisi include:
+- Estrazione di caratteristiche dalle firme
+- Calcolo di metriche di similarità
+- Generazione di un report dettagliato
+
+**Come utilizzare:**
+1. Caricare due immagini di firme
+2. Cliccare su "Confronta"
+3. Analizzare il report di similarità generato
+
+### 3. Analisi Font e Inchiostro
+
+Questa sezione analizza il tipo di font e l'inchiostro utilizzato in un documento. L'analisi include:
+- Rilevamento delle regioni di testo
+- Estrazione del testo
+- Analisi del font (serif/sans-serif, monospaced, grassetto, corsivo)
+- Analisi dell'inchiostro (tipo, colore, stampato/manoscritto)
+
+**Come utilizzare:**
+1. Caricare un'immagine contenente testo
+2. Cliccare su "Analizza"
+3. Esaminare il report dettagliato sul font e l'inchiostro
+
+### 4. Misurazione e Profilazione
+
+Questa sezione fornisce strumenti per misurare vari aspetti di un documento, come:
+- Spazio tra le linee
+- Spazio tra le parole
+- Margini
+- Inclinazione dei caratteri
+- Profilo di pressione
+
+**Come utilizzare:**
+1. Caricare un'immagine di un documento
+2. Cliccare su "Misura"
+3. Analizzare le misurazioni e i grafici generati
+
+### 5. Miglioramento Immagini
+
+Questa sezione offre vari filtri e tecniche per migliorare la qualità delle immagini:
+- Miglioramento del contrasto
+- Sharpening
+- Rilevamento dei bordi
+- Evidenziazione dei punti di pressione
+- Effetto rilievo
+- Mappa di calore
+
+**Come utilizzare:**
+1. Caricare un'immagine
+2. Selezionare il tipo di miglioramento desiderato
+3. Cliccare su "Migliora"
+4. Visualizzare l'immagine migliorata
+
+### 6. Machine Learning
+
+Questa sezione include due strumenti basati su machine learning:
+
+#### 6.1 Rilevamento Anomalie
+Utilizza algoritmi di Isolation Forest per rilevare anomalie nelle firme.
+
+**Come utilizzare:**
+1. Caricare un'immagine di firma
+2. Cliccare su "Rileva Anomalie"
+3. Analizzare il report che indica se la firma è anomala
+
+#### 6.2 Verifica Firme
+Utilizza una rete neurale siamese per verificare se due firme appartengono alla stessa persona.
+
+**Come utilizzare:**
+1. Caricare due immagini di firme
+2. Cliccare su "Verifica"
+3. Analizzare il report che indica la probabilità che le firme siano della stessa persona
+
+### 7. Sistema RAG
+
+Questa sezione permette di caricare, consultare e gestire documenti utilizzando un sistema RAG (Retrieval Augmented Generation).
+
+#### 7.1 Caricamento Documenti
+**Come utilizzare:**
+1. Caricare un documento (PDF, DOCX, PPTX, TXT)
+2. Cliccare su "Carica"
+3. Verificare che il documento sia stato indicizzato correttamente
+
+#### 7.2 Query
+**Come utilizzare:**
+1. Inserire una domanda o query nel campo di testo
+2. Cliccare su "Esegui Query"
+3. Leggere la risposta generata in base ai documenti caricati
+
+#### 7.3 Gestione Documenti
+**Come utilizzare:**
+1. Cliccare su "Lista Documenti" per vedere tutti i documenti caricati
+2. Per eliminare un documento, inserire l'ID del documento e cliccare su "Elimina Documento"
+
+## Consigli per Ottenere Risultati Ottimali
+
+1. **Qualità delle immagini**: Utilizzare immagini ad alta risoluzione per ottenere risultati migliori.
+2. **Illuminazione**: Assicurarsi che le immagini siano ben illuminate e non abbiano ombre eccessive.
+3. **Contrasto**: Le immagini con buon contrasto tra testo/firma e sfondo producono risultati migliori.
+4. **Formati supportati**: L'applicazione supporta i formati immagine più comuni (JPG, PNG) e vari formati di documento (PDF, DOCX, PPTX, TXT).
+
+## Limitazioni
+
+1. Il sistema RAG funziona in modalità di sola ricerca, senza generazione di risposte AI.
+2. I modelli di machine learning richiedono un addestramento specifico per casi d'uso particolari.
+3. L'analisi del font e dell'inchiostro potrebbe non essere accurata per scritture molto stilizzate o inusuali.
+
+## Risoluzione dei Problemi
+
+Se riscontri problemi con l'applicazione, prova le seguenti soluzioni:
+
+1. **Immagini non caricate correttamente**: Verifica che il formato dell'immagine sia supportato e che la dimensione non sia eccessiva.
+2. **Errori nell'analisi**: Prova a migliorare la qualità dell'immagine o a utilizzare la sezione di pre-elaborazione prima dell'analisi.
+3. **Prestazioni lente**: Le operazioni di machine learning possono richiedere tempo, specialmente su immagini di grandi dimensioni.
+
+Per ulteriori informazioni o assistenza, consulta la documentazione tecnica o contatta il supporto.

hf-space.yaml

@@ -0,0 +1,3 @@
+sdk: gradio
+sdk_version: 5.22.0
+app_file: app.py

requirements.txt

@@ -0,0 +1,164 @@
+aiofiles==23.2.1
+aiohappyeyeballs==2.6.1
+aiohttp==3.11.14
+aiosignal==1.3.2
+annotated-types==0.7.0
+anyio==4.9.0
+asgiref==3.8.1
+async-timeout==4.0.3
+attrs==25.3.0
+backoff==2.2.1
+bcrypt==4.3.0
+build==1.2.2.post1
+cachetools==5.5.2
+certifi==2025.1.31
+cffi==1.17.1
+charset-normalizer==3.4.1
+chroma-hnswlib==0.7.6
+chromadb==0.6.3
+click==8.1.8
+coloredlogs==15.0.1
+contourpy==1.3.1
+cryptography==44.0.2
+cycler==0.12.1
+dataclasses-json==0.6.7
+Deprecated==1.2.18
+distro==1.9.0
+durationpy==0.9
+exceptiongroup==1.2.2
+fastapi==0.115.11
+ffmpy==0.5.0
+filelock==3.13.1
+flatbuffers==25.2.10
+fonttools==4.56.0
+frozenlist==1.5.0
+fsspec==2024.6.1
+google-auth==2.38.0
+googleapis-common-protos==1.69.2
+gradio==5.22.0
+gradio_client==1.8.0
+greenlet==3.1.1
+groovy==0.1.2
+grpcio==1.71.0
+h11==0.14.0
+httpcore==1.0.7
+httptools==0.6.4
+httpx==0.28.1
+httpx-sse==0.4.0
+huggingface-hub==0.29.3
+humanfriendly==10.0
+idna==3.10
+importlib_metadata==8.6.1
+importlib_resources==6.5.2
+Jinja2==3.1.4
+joblib==1.4.2
+jsonpatch==1.33
+jsonpointer==3.0.0
+kiwisolver==1.4.8
+kubernetes==32.0.1
+langchain==0.3.21
+langchain-community==0.3.20
+langchain-core==0.3.47
+langchain-text-splitters==0.3.7
+langsmith==0.3.18
+lxml==5.3.1
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+marshmallow==3.26.1
+matplotlib==3.10.1
+mdurl==0.1.2
+mmh3==5.1.0
+monotonic==1.6
+mpmath==1.3.0
+multidict==6.2.0
+mypy-extensions==1.0.0
+networkx==3.3
+numpy==2.2.4
+oauthlib==3.2.2
+onnxruntime==1.21.0
+opencv-python==4.11.0.86
+opentelemetry-api==1.31.1
+opentelemetry-exporter-otlp-proto-common==1.31.1
+opentelemetry-exporter-otlp-proto-grpc==1.31.1
+opentelemetry-instrumentation==0.52b1
+opentelemetry-instrumentation-asgi==0.52b1
+opentelemetry-instrumentation-fastapi==0.52b1
+opentelemetry-proto==1.31.1
+opentelemetry-sdk==1.31.1
+opentelemetry-semantic-conventions==0.52b1
+opentelemetry-util-http==0.52b1
+orjson==3.10.15
+overrides==7.7.0
+packaging==24.2
+pandas==2.2.3
+pdfminer.six==20231228
+pdfplumber==0.11.5
+pillow==11.1.0
+posthog==3.21.0
+propcache==0.3.0
+protobuf==5.29.4
+pyasn1==0.6.1
+pyasn1_modules==0.4.1
+pycparser==2.22
+pydantic==2.10.6
+pydantic-settings==2.8.1
+pydantic_core==2.27.2
+pydub==0.25.1
+Pygments==2.19.1
+PyMuPDF==1.25.4
+pyparsing==3.2.1
+pypdfium2==4.30.1
+PyPika==0.48.9
+pyproject_hooks==1.2.0
+pytesseract==0.3.13
+python-dateutil==2.9.0.post0
+python-docx==1.1.2
+python-dotenv==1.0.1
+python-multipart==0.0.20
+python-pptx==1.0.2
+pytz==2025.1
+PyYAML==6.0.2
+regex==2024.11.6
+requests==2.32.3
+requests-oauthlib==2.0.0
+requests-toolbelt==1.0.0
+rich==13.9.4
+rsa==4.9
+ruff==0.11.2
+safehttpx==0.1.6
+safetensors==0.5.3
+scikit-learn==1.6.1
+scipy==1.15.2
+semantic-version==2.10.0
+sentence-transformers==3.4.1
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+SQLAlchemy==2.0.39
+starlette==0.46.1
+sympy==1.13.1
+tenacity==9.0.0
+threadpoolctl==3.6.0
+tokenizers==0.21.1
+tomli==2.2.1
+tomlkit==0.13.2
+torch==2.6.0+cpu
+torchaudio==2.6.0+cpu
+torchvision==0.21.0+cpu
+tqdm==4.67.1
+transformers==4.50.0
+typer==0.15.2
+typing-inspect==0.9.0
+typing_extensions==4.12.2
+tzdata==2025.1
+urllib3==2.3.0
+uvicorn==0.34.0
+uvloop==0.21.0
+watchfiles==1.0.4
+websocket-client==1.8.0
+websockets==15.0.1
+wrapt==1.17.2
+XlsxWriter==3.2.2
+yarl==1.18.3
+zipp==3.21.0
+zstandard==0.23.0

src/font_analysis.py

@@ -0,0 +1,466 @@
+import cv2
+import numpy as np
+import pytesseract
+from .preprocessing import ImagePreprocessor
+
+class FontAnalyzer:
+    """
+    Classe per l'analisi dei font e il riconoscimento del tipo di inchiostro.
+    Implementa funzionalità per identificare i font utilizzati nei documenti
+    e analizzare le caratteristiche dell'inchiostro.
+    """
+    
+    def __init__(self):
+        """Inizializza l'analizzatore di font."""
+        self.preprocessor = ImagePreprocessor()
+    
+    def detect_text_regions(self, image):
+        """
+        Rileva le regioni di testo in un'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            
+        Returns:
+            list: Lista di rettangoli (x, y, w, h) che contengono testo
+        """
+        # Converti in scala di grigi se necessario
+        if len(image.shape) > 2:
+            gray = self.preprocessor.convert_to_grayscale(image)
+        else:
+            gray = image
+        
+        # Applica soglia per binarizzare l'immagine
+        binary = self.preprocessor.threshold_image(gray, method='adaptive')
+        
+        # Applica operazioni morfologiche per connettere i componenti del testo
+        kernel = np.ones((5, 1), np.uint8)  # Kernel rettangolare orizzontale
+        dilated = cv2.dilate(binary, kernel, iterations=2)
+        
+        # Trova i contorni
+        contours, _ = cv2.findContours(dilated, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        
+        # Filtra i contorni per dimensione
+        text_regions = []
+        for contour in contours:
+            x, y, w, h = cv2.boundingRect(contour)
+            
+            # Filtra i contorni troppo piccoli
+            if w > 20 and h > 8 and w > h:  # Probabilmente testo
+                text_regions.append((x, y, w, h))
+        
+        return text_regions
+    
+    def extract_text(self, image, text_regions=None):
+        """
+        Estrae il testo da un'immagine utilizzando OCR.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            text_regions (list, optional): Lista di regioni di testo (x, y, w, h)
+            
+        Returns:
+            dict: Dizionario con il testo estratto e le informazioni sulle regioni
+        """
+        # Se non sono fornite regioni di testo, rileva automaticamente
+        if text_regions is None:
+            text_regions = self.detect_text_regions(image)
+        
+        # Converti in scala di grigi se necessario
+        if len(image.shape) > 2:
+            gray = self.preprocessor.convert_to_grayscale(image)
+        else:
+            gray = image
+        
+        # Prepara il risultato
+        result = {
+            'full_text': '',
+            'regions': []
+        }
+        
+        # Estrai il testo da ciascuna regione
+        for i, (x, y, w, h) in enumerate(text_regions):
+            # Estrai la regione
+            roi = gray[y:y+h, x:x+w]
+            
+            # Applica miglioramenti all'immagine per OCR
+            roi = cv2.resize(roi, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)
+            roi = cv2.GaussianBlur(roi, (5, 5), 0)
+            roi = cv2.threshold(roi, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]
+            
+            # Esegui OCR
+            text = pytesseract.image_to_string(roi, config='--psm 6')
+            
+            # Aggiungi al risultato
+            if text.strip():
+                result['full_text'] += text + '\n'
+                result['regions'].append({
+                    'id': i,
+                    'bbox': (x, y, w, h),
+                    'text': text.strip()
+                })
+        
+        return result
+    
+    def analyze_font(self, image, text_regions=None):
+        """
+        Analizza i font presenti in un'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            text_regions (list, optional): Lista di regioni di testo (x, y, w, h)
+            
+        Returns:
+            dict: Dizionario con le informazioni sui font
+        """
+        # Se non sono fornite regioni di testo, rileva automaticamente
+        if text_regions is None:
+            text_regions = self.detect_text_regions(image)
+        
+        # Converti in scala di grigi se necessario
+        if len(image.shape) > 2:
+            gray = self.preprocessor.convert_to_grayscale(image)
+        else:
+            gray = image
+        
+        # Prepara il risultato
+        result = {
+            'regions': []
+        }
+        
+        # Analizza ciascuna regione
+        for i, (x, y, w, h) in enumerate(text_regions):
+            # Estrai la regione
+            roi = gray[y:y+h, x:x+w]
+            
+            # Applica miglioramenti all'immagine per OCR
+            roi = cv2.resize(roi, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)
+            roi = cv2.GaussianBlur(roi, (5, 5), 0)
+            roi = cv2.threshold(roi, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)[1]
+            
+            # Esegui OCR con output dettagliato
+            ocr_data = pytesseract.image_to_data(roi, output_type=pytesseract.Output.DICT)
+            
+            # Analizza le caratteristiche del font
+            font_info = self._analyze_font_characteristics(roi, ocr_data)
+            
+            # Aggiungi al risultato
+            result['regions'].append({
+                'id': i,
+                'bbox': (x, y, w, h),
+                'font_info': font_info
+            })
+        
+        return result
+    
+    def _analyze_font_characteristics(self, image, ocr_data):
+        """
+        Analizza le caratteristiche del font in una regione di testo.
+        
+        Args:
+            image (numpy.ndarray): Immagine della regione di testo
+            ocr_data (dict): Dati OCR dalla regione
+            
+        Returns:
+            dict: Caratteristiche del font
+        """
+        # Inizializza le caratteristiche
+        font_info = {
+            'is_serif': False,
+            'is_monospaced': False,
+            'is_bold': False,
+            'is_italic': False,
+            'font_size': 0,
+            'confidence': 0,
+            'possible_fonts': []
+        }
+        
+        # Estrai le caratteristiche dai dati OCR
+        if 'conf' in ocr_data and len(ocr_data['conf']) > 0:
+            # Calcola la confidenza media
+            valid_conf = [float(conf) for conf in ocr_data['conf'] if conf != '-1']
+            if valid_conf:
+                font_info['confidence'] = sum(valid_conf) / len(valid_conf)
+        
+        # Analizza la spaziatura per determinare se è monospaced
+        if 'text' in ocr_data and 'left' in ocr_data and len(ocr_data['text']) > 1:
+            # Filtra solo le parole valide
+            valid_indices = [i for i, text in enumerate(ocr_data['text']) if text.strip()]
+            
+            if len(valid_indices) > 1:
+                # Calcola le distanze tra le parole
+                lefts = [ocr_data['left'][i] for i in valid_indices]
+                widths = [ocr_data['width'][i] for i in valid_indices]
+                
+                # Calcola la deviazione standard delle larghezze dei caratteri
+                char_widths = []
+                for i in valid_indices:
+                    if ocr_data['text'][i] and len(ocr_data['text'][i]) > 0:
+                        char_width = ocr_data['width'][i] / len(ocr_data['text'][i])
+                        char_widths.append(char_width)
+                
+                if char_widths:
+                    std_dev = np.std(char_widths)
+                    mean_width = np.mean(char_widths)
+                    
+                    # Se la deviazione standard è bassa rispetto alla media, è probabilmente monospaced
+                    if std_dev / mean_width < 0.1:
+                        font_info['is_monospaced'] = True
+        
+        # Analizza l'immagine per determinare se è serif o sans-serif
+        # Questo è un approccio semplificato basato sul conteggio dei pixel
+        binary = cv2.threshold(image, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)[1]
+        
+        # Calcola il numero di pixel bianchi (testo) e neri (sfondo)
+        white_pixels = cv2.countNonZero(binary)
+        total_pixels = binary.shape[0] * binary.shape[1]
+        black_pixels = total_pixels - white_pixels
+        
+        # Calcola la densità del testo
+        text_density = white_pixels / total_pixels if total_pixels > 0 else 0
+        
+        # Applica operazioni morfologiche per rilevare caratteristiche serif
+        kernel = np.ones((2, 2), np.uint8)
+        eroded = cv2.erode(binary, kernel, iterations=1)
+        
+        # Calcola la differenza tra l'immagine originale e quella erosa
+        diff = cv2.subtract(binary, eroded)
+        
+        # Conta i pixel nella differenza
+        diff_pixels = cv2.countNonZero(diff)
+        
+        # Calcola il rapporto tra i pixel di differenza e i pixel bianchi originali
+        serif_ratio = diff_pixels / white_pixels if white_pixels > 0 else 0
+        
+        # Se il rapporto è alto, è probabilmente serif
+        if serif_ratio > 0.2:
+            font_info['is_serif'] = True
+        
+        # Stima la dimensione del font
+        if 'height' in ocr_data and len(ocr_data['height']) > 0:
+            valid_heights = [h for h in ocr_data['height'] if h > 0]
+            if valid_heights:
+                font_info['font_size'] = sum(valid_heights) / len(valid_heights) / 2  # Approssimazione
+        
+        # Determina se è grassetto
+        if text_density > 0.4:  # Soglia arbitraria
+            font_info['is_bold'] = True
+        
+        # Determina se è corsivo
+        # Questo richiederebbe un'analisi più complessa dell'inclinazione dei caratteri
+        # Per ora, utilizziamo un'euristica basata sui dati OCR
+        if 'text' in ocr_data and 'left' in ocr_data and 'width' in ocr_data:
+            # Calcola l'inclinazione media dei caratteri
+            # Questo è un approccio semplificato
+            font_info['is_italic'] = False  # Implementazione semplificata
+        
+        # Suggerisci possibili font
+        if font_info['is_serif'] and font_info['is_monospaced']:
+            font_info['possible_fonts'] = ['Courier', 'Courier New', 'Consolas']
+        elif font_info['is_serif'] and not font_info['is_monospaced']:
+            if font_info['is_bold']:
+                font_info['possible_fonts'] = ['Times New Roman Bold', 'Georgia Bold', 'Garamond Bold']
+            else:
+                font_info['possible_fonts'] = ['Times New Roman', 'Georgia', 'Garamond']
+        elif not font_info['is_serif'] and font_info['is_monospaced']:
+            font_info['possible_fonts'] = ['Monaco', 'Menlo', 'Lucida Console']
+        else:  # sans-serif, non-monospaced
+            if font_info['is_bold']:
+                font_info['possible_fonts'] = ['Arial Bold', 'Helvetica Bold', 'Calibri Bold']
+            else:
+                font_info['possible_fonts'] = ['Arial', 'Helvetica', 'Calibri']
+        
+        return font_info
+    
+    def analyze_ink(self, image):
+        """
+        Analizza il tipo di inchiostro utilizzato in un'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            
+        Returns:
+            dict: Informazioni sul tipo di inchiostro
+        """
+        # Verifica che l'immagine sia a colori
+        if len(image.shape) < 3:
+            # Converti in BGR se è in scala di grigi
+            image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
+        
+        # Converti in HSV per un'analisi migliore del colore
+        hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+        
+        # Estrai i canali HSV
+        h, s, v = cv2.split(hsv)
+        
+        # Crea una maschera per isolare l'inchiostro (pixel scuri)
+        _, ink_mask = cv2.threshold(v, 150, 255, cv2.THRESH_BINARY_INV)
+        
+        # Applica la maschera ai canali HSV
+        h_ink = cv2.bitwise_and(h, h, mask=ink_mask)
+        s_ink = cv2.bitwise_and(s, s, mask=ink_mask)
+        
+        # Calcola le statistiche dei canali HSV per l'inchiostro
+        h_values = h_ink[ink_mask > 0]
+        s_values = s_ink[ink_mask > 0]
+        v_values = 255 - v[ink_mask > 0]  # Inverti V per ottenere l'intensità dell'inchiostro
+        
+        # Se non ci sono pixel di inchiostro, restituisci un risultato predefinito
+        if len(h_values) == 0:
+            return {
+                'ink_type': 'unknown',
+                'ink_color': 'unknown',
+                'is_printed': False,
+                'confidence': 0,
+                'details': {
+                    'hue_mean': 0,
+                    'saturation_mean': 0,
+                    'value_mean': 0,
+                    'hue_std': 0,
+                    'saturation_std': 0,
+                    'value_std': 0,
+                    'ink_coverage': 0
+                }
+            }
+        
+        # Calcola le statistiche
+        hue_mean = np.mean(h_values)
+        saturation_mean = np.mean(s_values)
+        value_mean = np.mean(v_values)
+        hue_std = np.std(h_values)
+        saturation_std = np.std(s_values)
+        value_std = np.std(v_values)
+        
+        # Calcola la copertura dell'inchiostro
+        ink_coverage = np.count_nonzero(ink_mask) / (ink_mask.shape[0] * ink_mask.shape[1])
+        
+        # Determina il colore dell'inchiostro
+        ink_color = self._determine_ink_color(hue_mean, saturation_mean, value_mean)
+        
+        # Determina se è stampato o scritto a mano
+        is_printed = self._is_printed_ink(value_std, saturation_std, ink_coverage)
+        
+        # Determina il tipo di inchiostro
+        ink_type, confidence = self._determine_ink_type(
+            hue_mean, saturation_mean, value_mean, 
+            hue_std, saturation_std, value_std, 
+            ink_coverage, is_printed
+        )
+        
+        return {
+            'ink_type': ink_type,
+            'ink_color': ink_color,
+            'is_printed': is_printed,
+            'confidence': confidence,
+            'details': {
+                'hue_mean': float(hue_mean),
+                'saturation_mean': float(saturation_mean),
+                'value_mean': float(value_mean),
+                'hue_std': float(hue_std),
+                'saturation_std': float(saturation_std),
+                'value_std': float(value_std),
+                'ink_coverage': float(ink_coverage)
+            }
+        }
+    
+    def _determine_ink_color(self, hue_mean, saturation_mean, value_mean):
+        """
+        Determina il colore dell'inchiostro in base ai valori HSV.
+        
+        Args:
+            hue_mean (float): Media del canale H
+            saturation_mean (float): Media del canale S
+            value_mean (float): Media del canale V
+            
+        Returns:
+            str: Nome del colore dell'inchiostro
+        """
+        # Se la saturazione è bassa, è probabilmente nero o grigio
+        if saturation_mean < 50:
+            if value_mean > 200:
+                return 'black'
+            else:
+                return 'gray'
+        
+        # Altrimenti, determina il colore in base alla tonalità
+        if 0 <= hue_mean < 30 or 330 <= hue_mean <= 360:
+            return 'red'
+        elif 30 <= hue_mean < 90:
+            return 'yellow'
+        elif 90 <= hue_mean < 150:
+            return 'green'
+        elif 150 <= hue_mean < 210:
+            return 'cyan'
+        elif 210 <= hue_mean < 270:
+            return 'blue'
+        elif 270 <= hue_mean < 330:
+            return 'magenta'
+        else:
+            return 'unknown'
+    
+    def _is_printed_ink(self, value_std, saturation_std, ink_coverage):
+        """
+        Determina se l'inchiostro è stampato o scritto a mano.
+        
+        Args:
+            value_std (float): Deviazione standard del canale V
+            saturation_std (float): Deviazione standard del canale S
+            ink_coverage (float): Percentuale di copertura dell'inchiostro
+            
+        Returns:
+            bool: True se l'inchiostro è probabilmente stampato, False altrimenti
+        """
+        # L'inchiostro stampato tende ad avere una deviazione standard più bassa
+        # e una copertura più uniforme
+        if value_std < 30 and saturation_std < 20:
+            return True
+        
+        # Se la copertura è molto alta, è probabilmente stampato
+        if ink_coverage > 0.4:
+            return True
+        
+        return False
+    
+    def _determine_ink_type(self, hue_mean, saturation_mean, value_mean, 
+                           hue_std, saturation_std, value_std, 
+                           ink_coverage, is_printed):
+        """
+        Determina il tipo di inchiostro in base alle statistiche HSV.
+        
+        Args:
+            hue_mean (float): Media del canale H
+            saturation_mean (float): Media del canale S
+            value_mean (float): Media del canale V
+            hue_std (float): Deviazione standard del canale H
+            saturation_std (float): Deviazione standard del canale S
+            value_std (float): Deviazione standard del canale V
+            ink_coverage (float): Percentuale di copertura dell'inchiostro
+            is_printed (bool): Se l'inchiostro è stampato o scritto a mano
+            
+        Returns:
+            tuple: (tipo_inchiostro, confidenza)
+        """
+        if is_printed:
+            # Inchiostro stampato
+            if saturation_mean < 30 and value_mean > 200:
+                return 'laser_printer', 0.8
+            elif saturation_mean < 50:
+                return 'inkjet_printer', 0.7
+            else:
+                return 'color_printer', 0.6
+        else:
+            # Inchiostro scritto a mano
+            if saturation_mean < 30 and value_mean > 200:
+                # Penna a sfera (biro)
+                return 'ballpoint_pen', 0.7
+            elif saturation_mean > 100 and value_std > 40:
+                # Pennarello
+                return 'marker', 0.8
+            elif value_mean < 150 and value_std < 30:
+                # Penna stilografica
+                return 'fountain_pen', 0.6
+            elif saturation_mean < 50 and value_mean < 180:
+                # Matita
+                return 'pencil', 0.7
+            else:
+                return 'unknown_pen', 0.4

src/image_enhancer.py

@@ -0,0 +1,511 @@
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from .preprocessing import ImagePreprocessor
+
+class ImageEnhancer:
+    """
+    Classe per l'elaborazione avanzata delle immagini di firme e documenti.
+    Implementa funzionalità per migliorare la qualità delle immagini,
+    evidenziare dettagli e applicare filtri speciali per l'analisi forense.
+    """
+    
+    def __init__(self):
+        """Inizializza l'enhancer di immagini."""
+        self.preprocessor = ImagePreprocessor()
+    
+    def enhance_contrast(self, image, method='clahe'):
+        """
+        Migliora il contrasto di un'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            method (str): Metodo di miglioramento ('clahe', 'histogram_eq', 'adaptive')
+            
+        Returns:
+            numpy.ndarray: Immagine con contrasto migliorato
+        """
+        # Converti in scala di grigi se necessario
+        if len(image.shape) > 2:
+            gray = self.preprocessor.convert_to_grayscale(image)
+        else:
+            gray = image.copy()
+        
+        if method == 'clahe':
+            # Contrast Limited Adaptive Histogram Equalization
+            clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+            enhanced = clahe.apply(gray)
+        elif method == 'histogram_eq':
+            # Equalizzazione dell'istogramma globale
+            enhanced = cv2.equalizeHist(gray)
+        elif method == 'adaptive':
+            # Miglioramento adattivo del contrasto
+            enhanced = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+                                           cv2.THRESH_BINARY, 11, 2)
+        else:
+            raise ValueError(f"Metodo di miglioramento del contrasto non supportato: {method}")
+        
+        return enhanced
+    
+    def sharpen_image(self, image, kernel_size=3, strength=1.0):
+        """
+        Applica un filtro di sharpening all'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            kernel_size (int): Dimensione del kernel
+            strength (float): Intensità dell'effetto di sharpening
+            
+        Returns:
+            numpy.ndarray: Immagine affilata
+        """
+        # Converti in scala di grigi se necessario
+        if len(image.shape) > 2:
+            gray = self.preprocessor.convert_to_grayscale(image)
+        else:
+            gray = image.copy()
+        
+        # Applica un filtro gaussiano per ridurre il rumore
+        blurred = cv2.GaussianBlur(gray, (kernel_size, kernel_size), 0)
+        
+        # Calcola la maschera di sharpening (immagine originale - immagine sfocata)
+        mask = cv2.subtract(gray, blurred)
+        
+        # Applica la maschera all'immagine originale
+        sharpened = cv2.addWeighted(gray, 1.0, mask, strength, 0)
+        
+        return sharpened
+    
+    def apply_edge_detection(self, image, method='canny'):
+        """
+        Applica un rilevatore di bordi all'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            method (str): Metodo di rilevamento bordi ('canny', 'sobel', 'laplacian')
+            
+        Returns:
+            numpy.ndarray: Immagine con bordi rilevati
+        """
+        # Converti in scala di grigi se necessario
+        if len(image.shape) > 2:
+            gray = self.preprocessor.convert_to_grayscale(image)
+        else:
+            gray = image.copy()
+        
+        # Applica un filtro gaussiano per ridurre il rumore
+        blurred = cv2.GaussianBlur(gray, (5, 5), 0)
+        
+        if method == 'canny':
+            # Rilevatore di bordi Canny
+            edges = cv2.Canny(blurred, 50, 150)
+        elif method == 'sobel':
+            # Rilevatore di bordi Sobel
+            sobelx = cv2.Sobel(blurred, cv2.CV_64F, 1, 0, ksize=3)
+            sobely = cv2.Sobel(blurred, cv2.CV_64F, 0, 1, ksize=3)
+            
+            # Calcola il gradiente
+            magnitude = cv2.magnitude(sobelx, sobely)
+            
+            # Normalizza e converti in uint8
+            edges = cv2.normalize(magnitude, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U)
+        elif method == 'laplacian':
+            # Rilevatore di bordi Laplaciano
+            laplacian = cv2.Laplacian(blurred, cv2.CV_64F)
+            
+            # Normalizza e converti in uint8
+            edges = cv2.normalize(laplacian, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U)
+        else:
+            raise ValueError(f"Metodo di rilevamento bordi non supportato: {method}")
+        
+        return edges
+    
+    def highlight_pressure_points(self, image, threshold=50):
+        """
+        Evidenzia i punti di pressione in una firma.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            threshold (int): Soglia per considerare un punto come punto di pressione
+            
+        Returns:
+            numpy.ndarray: Immagine con punti di pressione evidenziati
+        """
+        # Converti in scala di grigi se necessario
+        if len(image.shape) > 2:
+            gray = self.preprocessor.convert_to_grayscale(image)
+        else:
+            gray = image.copy()
+        
+        # Inverti l'immagine (testo bianco su sfondo nero)
+        gray_inv = cv2.bitwise_not(gray)
+        
+        # Applica una soglia per isolare il testo
+        _, binary = cv2.threshold(gray_inv, threshold, 255, cv2.THRESH_BINARY)
+        
+        # Crea un'immagine a colori per la visualizzazione
+        result = cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR)
+        
+        # Applica una mappa di colori per evidenziare i punti di pressione
+        # Più scuro è il pixel, maggiore è la pressione
+        for i in range(gray.shape[0]):
+            for j in range(gray.shape[1]):
+                if binary[i, j] > 0:
+                    # Calcola l'intensità normalizzata (0-1)
+                    intensity = gray_inv[i, j] / 255.0
+                    
+                    # Applica una mappa di colori (blu -> verde -> rosso)
+                    if intensity < 0.33:
+                        # Blu (bassa pressione)
+                        result[i, j] = [255, 0, 0]
+                    elif intensity < 0.66:
+                        # Verde (media pressione)
+                        result[i, j] = [0, 255, 0]
+                    else:
+                        # Rosso (alta pressione)
+                        result[i, j] = [0, 0, 255]
+        
+        return result
+    
+    def extract_profile(self, image, direction='horizontal'):
+        """
+        Estrae il profilo di un'immagine in una direzione specifica.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            direction (str): Direzione del profilo ('horizontal', 'vertical')
+            
+        Returns:
+            numpy.ndarray: Profilo estratto
+        """
+        # Converti in scala di grigi se necessario
+        if len(image.shape) > 2:
+            gray = self.preprocessor.convert_to_grayscale(image)
+        else:
+            gray = image.copy()
+        
+        # Inverti l'immagine (testo bianco su sfondo nero)
+        gray_inv = cv2.bitwise_not(gray)
+        
+        if direction == 'horizontal':
+            # Somma i pixel per ogni riga
+            profile = np.sum(gray_inv, axis=1)
+        elif direction == 'vertical':
+            # Somma i pixel per ogni colonna
+            profile = np.sum(gray_inv, axis=0)
+        else:
+            raise ValueError(f"Direzione del profilo non supportata: {direction}")
+        
+        # Normalizza il profilo
+        if np.max(profile) > 0:
+            profile = profile / np.max(profile)
+        
+        return profile
+    
+    def visualize_profile(self, image, save_path=None):
+        """
+        Visualizza i profili orizzontale e verticale di un'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            save_path (str, optional): Percorso dove salvare l'immagine
+            
+        Returns:
+            matplotlib.figure.Figure: Figura con la visualizzazione
+        """
+        # Estrai i profili
+        h_profile = self.extract_profile(image, direction='horizontal')
+        v_profile = self.extract_profile(image, direction='vertical')
+        
+        # Crea una figura con più sottografici
+        fig, axs = plt.subplots(1, 3, figsize=(15, 5))
+        
+        # Immagine originale
+        if len(image.shape) > 2:
+            axs[0].imshow(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+        else:
+            axs[0].imshow(image, cmap='gray')
+        axs[0].set_title('Immagine Originale')
+        axs[0].axis('off')
+        
+        # Profilo orizzontale
+        axs[1].plot(h_profile, range(len(h_profile)), 'b-')
+        axs[1].invert_yaxis()  # Inverti l'asse y per corrispondere all'immagine
+        axs[1].set_title('Profilo Orizzontale')
+        axs[1].set_xlabel('Intensità Normalizzata')
+        axs[1].set_ylabel('Riga')
+        
+        # Profilo verticale
+        axs[2].plot(v_profile, 'r-')
+        axs[2].set_title('Profilo Verticale')
+        axs[2].set_xlabel('Colonna')
+        axs[2].set_ylabel('Intensità Normalizzata')
+        
+        plt.tight_layout()
+        
+        # Salva l'immagine se richiesto
+        if save_path:
+            plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        
+        return fig
+    
+    def apply_color_filter(self, image, color_range):
+        """
+        Applica un filtro di colore all'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input (BGR)
+            color_range (dict): Intervallo di colori in formato HSV
+                                {'lower': [h_min, s_min, v_min], 'upper': [h_max, s_max, v_max]}
+            
+        Returns:
+            numpy.ndarray: Immagine filtrata
+        """
+        # Verifica che l'immagine sia a colori
+        if len(image.shape) < 3:
+            # Converti in BGR se è in scala di grigi
+            image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
+        
+        # Converti in HSV
+        hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+        
+        # Crea una maschera per il colore specificato
+        lower = np.array(color_range['lower'])
+        upper = np.array(color_range['upper'])
+        mask = cv2.inRange(hsv, lower, upper)
+        
+        # Applica la maschera all'immagine originale
+        filtered = cv2.bitwise_and(image, image, mask=mask)
+        
+        return filtered
+    
+    def extract_stamp(self, image):
+        """
+        Estrae i timbri da un'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input (BGR)
+            
+        Returns:
+            tuple: (immagine_originale_senza_timbri, timbri_estratti)
+        """
+        # Verifica che l'immagine sia a colori
+        if len(image.shape) < 3:
+            # Converti in BGR se è in scala di grigi
+            image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
+        
+        # Definisci intervalli di colore per i timbri comuni
+        color_ranges = [
+            # Blu (timbri comuni)
+            {'lower': [100, 50, 50], 'upper': [140, 255, 255]},
+            # Rosso (timbri comuni)
+            {'lower': [0, 50, 50], 'upper': [10, 255, 255]},
+            # Rosso (parte alta dello spettro HSV)
+            {'lower': [170, 50, 50], 'upper': [180, 255, 255]},
+            # Viola (alcuni timbri ufficiali)
+            {'lower': [140, 50, 50], 'upper': [170, 255, 255]}
+        ]
+        
+        # Converti in HSV
+        hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+        
+        # Crea una maschera combinata per tutti i colori
+        combined_mask = np.zeros((image.shape[0], image.shape[1]), dtype=np.uint8)
+        
+        for color_range in color_ranges:
+            lower = np.array(color_range['lower'])
+            upper = np.array(color_range['upper'])
+            mask = cv2.inRange(hsv, lower, upper)
+            combined_mask = cv2.bitwise_or(combined_mask, mask)
+        
+        # Applica operazioni morfologiche per migliorare la maschera
+        kernel = np.ones((5, 5), np.uint8)
+        combined_mask = cv2.morphologyEx(combined_mask, cv2.MORPH_OPEN, kernel)
+        combined_mask = cv2.morphologyEx(combined_mask, cv2.MORPH_CLOSE, kernel)
+        
+        # Estrai i timbri
+        stamps = cv2.bitwise_and(image, image, mask=combined_mask)
+        
+        # Crea un'immagine senza timbri
+        inv_mask = cv2.bitwise_not(combined_mask)
+        image_without_stamps = cv2.bitwise_and(image, image, mask=inv_mask)
+        
+        return image_without_stamps, stamps
+    
+    def convert_to_grayscale_enhanced(self, image, method='weighted'):
+        """
+        Converte un'immagine a colori in scala di grigi con metodi avanzati.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input (BGR)
+            method (str): Metodo di conversione ('weighted', 'luminosity', 'desaturation', 'decomposition')
+            
+        Returns:
+            numpy.ndarray: Immagine in scala di grigi
+        """
+        # Verifica che l'immagine sia a colori
+        if len(image.shape) < 3:
+            return image.copy()
+        
+        if method == 'weighted':
+            # Metodo standard (ponderato)
+            gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+        elif method == 'luminosity':
+            # Metodo della luminosità (pesi personalizzati)
+            b, g, r = cv2.split(image)
+            gray = np.uint8(0.07 * b + 0.72 * g + 0.21 * r)
+        elif method == 'desaturation':
+            # Metodo della desaturazione (media di min e max)
+            b, g, r = cv2.split(image)
+            min_val = np.minimum(np.minimum(r, g), b)
+            max_val = np.maximum(np.maximum(r, g), b)
+            gray = np.uint8((min_val + max_val) / 2)
+        elif method == 'decomposition':
+            # Metodo della decomposizione (massimo dei canali)
+            b, g, r = cv2.split(image)
+            gray = np.maximum(np.maximum(r, g), b)
+        else:
+            raise ValueError(f"Metodo di conversione in scala di grigi non supportato: {method}")
+        
+        return gray
+    
+    def apply_emboss_effect(self, image, direction='top-left'):
+        """
+        Applica un effetto di rilievo all'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            direction (str): Direzione della luce ('top-left', 'top-right', 'bottom-left', 'bottom-right')
+            
+        Returns:
+            numpy.ndarray: Immagine con effetto di rilievo
+        """
+        # Converti in scala di grigi se necessario
+        if len(image.shape) > 2:
+            gray = self.preprocessor.convert_to_grayscale(image)
+        else:
+            gray = image.copy()
+        
+        # Definisci il kernel in base alla direzione
+        if direction == 'top-left':
+            kernel = np.array([[-1, -1, 0],
+                              [-1, 0, 1],
+                              [0, 1, 1]])
+        elif direction == 'top-right':
+            kernel = np.array([[0, -1, -1],
+                              [1, 0, -1],
+                              [1, 1, 0]])
+        elif direction == 'bottom-left':
+            kernel = np.array([[0, 1, 1],
+                              [-1, 0, 1],
+                              [-1, -1, 0]])
+        elif direction == 'bottom-right':
+            kernel = np.array([[1, 1, 0],
+                              [1, 0, -1],
+                              [0, -1, -1]])
+        else:
+            raise ValueError(f"Direzione non supportata: {direction}")
+        
+        # Applica il filtro
+        embossed = cv2.filter2D(gray, -1, kernel)
+        
+        # Aggiungi 128 per spostare i valori nel range medio
+        embossed = cv2.add(embossed, 128)
+        
+        return embossed
+    
+    def create_signature_heatmap(self, image, kernel_size=15):
+        """
+        Crea una mappa di calore della firma per evidenziare le aree di maggiore intensità.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            kernel_size (int): Dimensione del kernel per il filtro gaussiano
+            
+        Returns:
+            numpy.ndarray: Mappa di calore della firma
+        """
+        # Converti in scala di grigi se necessario
+        if len(image.shape) > 2:
+            gray = self.preprocessor.convert_to_grayscale(image)
+        else:
+            gray = image.copy()
+        
+        # Inverti l'immagine (testo bianco su sfondo nero)
+        gray_inv = cv2.bitwise_not(gray)
+        
+        # Applica un filtro gaussiano per creare l'effetto di calore
+        heatmap = cv2.GaussianBlur(gray_inv, (kernel_size, kernel_size), 0)
+        
+        # Normalizza la mappa di calore
+        heatmap = cv2.normalize(heatmap, None, 0, 255, cv2.NORM_MINMAX, cv2.CV_8U)
+        
+        # Applica una mappa di colori
+        heatmap_color = cv2.applyColorMap(heatmap, cv2.COLORMAP_JET)
+        
+        # Crea una maschera per isolare la firma
+        _, mask = cv2.threshold(gray_inv, 10, 255, cv2.THRESH_BINARY)
+        
+        # Dilata la maschera per includere le aree circostanti
+        kernel = np.ones((5, 5), np.uint8)
+        mask_dilated = cv2.dilate(mask, kernel, iterations=2)
+        
+        # Applica la maschera alla mappa di calore
+        result = cv2.bitwise_and(heatmap_color, heatmap_color, mask=mask_dilated)
+        
+        # Crea un'immagine di sfondo bianco
+        background = np.ones_like(image) * 255
+        if len(background.shape) < 3:
+            background = cv2.cvtColor(background, cv2.COLOR_GRAY2BGR)
+        
+        # Combina lo sfondo con la mappa di calore
+        mask_dilated_3ch = cv2.cvtColor(mask_dilated, cv2.COLOR_GRAY2BGR) / 255.0
+        result = background * (1 - mask_dilated_3ch) + result * mask_dilated_3ch
+        
+        return result.astype(np.uint8)
+    
+    def enhance_signature(self, image):
+        """
+        Applica una serie di miglioramenti a un'immagine di firma.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            
+        Returns:
+            dict: Dizionario con diverse versioni migliorate della firma
+        """
+        # Carica l'immagine se è un percorso file
+        if isinstance(image, str):
+            image = self.preprocessor.load_image(image)
+        
+        # Converti in scala di grigi
+        gray = self.preprocessor.convert_to_grayscale(image)
+        
+        # Migliora il contrasto
+        contrast_enhanced = self.enhance_contrast(gray, method='clahe')
+        
+        # Applica sharpening
+        sharpened = self.sharpen_image(gray, kernel_size=3, strength=1.5)
+        
+        # Rileva i bordi
+        edges = self.apply_edge_detection(gray, method='canny')
+        
+        # Evidenzia i punti di pressione
+        pressure_points = self.highlight_pressure_points(gray)
+        
+        # Applica effetto di rilievo
+        embossed = self.apply_emboss_effect(gray)
+        
+        # Crea una mappa di calore
+        heatmap = self.create_signature_heatmap(gray)
+        
+        return {
+            'original': image,
+            'grayscale': gray,
+            'contrast_enhanced': contrast_enhanced,
+            'sharpened': sharpened,
+            'edges': edges,
+            'pressure_points': pressure_points,
+            'embossed': embossed,
+            'heatmap': heatmap
+        }

src/measurement.py

@@ -0,0 +1,633 @@
+import cv2
+import numpy as np
+import matplotlib.pyplot as plt
+from .preprocessing import ImagePreprocessor
+
+class MeasurementTool:
+    """
+    Classe per la misurazione e profilazione di documenti e firme.
+    Implementa funzionalità per misurare interlinea, spazi, margini,
+    e generare profili di analisi.
+    """
+    
+    def __init__(self):
+        """Inizializza lo strumento di misurazione."""
+        self.preprocessor = ImagePreprocessor()
+    
+    def detect_lines(self, image, method='projection'):
+        """
+        Rileva le linee di testo in un'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            method (str): Metodo di rilevamento ('projection', 'hough')
+            
+        Returns:
+            list: Lista di coordinate y delle linee di testo
+        """
+        # Converti in scala di grigi se necessario
+        if len(image.shape) > 2:
+            gray = self.preprocessor.convert_to_grayscale(image)
+        else:
+            gray = image
+        
+        # Binarizza l'immagine
+        binary = self.preprocessor.threshold_image(gray, method='adaptive')
+        
+        if method == 'projection':
+            # Metodo della proiezione orizzontale
+            # Somma i pixel bianchi per ogni riga
+            projection = np.sum(binary, axis=1)
+            
+            # Normalizza la proiezione
+            projection = projection / np.max(projection)
+            
+            # Trova i picchi nella proiezione (linee di testo)
+            lines = []
+            threshold = 0.3  # Soglia per considerare un picco
+            in_line = False
+            start_line = 0
+            
+            for i in range(len(projection)):
+                if projection[i] > threshold and not in_line:
+                    in_line = True
+                    start_line = i
+                elif projection[i] <= threshold and in_line:
+                    in_line = False
+                    mid_line = (start_line + i) // 2
+                    lines.append(mid_line)
+            
+            # Se l'ultima linea non è stata chiusa
+            if in_line:
+                mid_line = (start_line + len(projection) - 1) // 2
+                lines.append(mid_line)
+            
+        elif method == 'hough':
+            # Metodo delle trasformate di Hough
+            edges = cv2.Canny(binary, 50, 150, apertureSize=3)
+            
+            # Rileva le linee
+            lines_hough = cv2.HoughLines(edges, 1, np.pi/180, threshold=100)
+            
+            # Filtra le linee orizzontali
+            lines = []
+            if lines_hough is not None:
+                for line in lines_hough:
+                    rho, theta = line[0]
+                    # Considera solo le linee orizzontali (theta vicino a 0 o pi)
+                    if (theta < 0.1 or abs(theta - np.pi) < 0.1):
+                        a = np.cos(theta)
+                        b = np.sin(theta)
+                        x0 = a * rho
+                        y0 = b * rho
+                        # y = (rho - x * cos(theta)) / sin(theta)
+                        # Per linee orizzontali, y è costante
+                        y = int(y0)
+                        lines.append(y)
+            
+            # Ordina le linee per posizione y
+            lines.sort()
+        else:
+            raise ValueError(f"Metodo di rilevamento linee non supportato: {method}")
+        
+        return lines
+    
+    def measure_line_spacing(self, image):
+        """
+        Misura lo spazio tra le linee di testo.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            
+        Returns:
+            dict: Informazioni sullo spazio tra le linee
+        """
+        # Rileva le linee
+        lines = self.detect_lines(image)
+        
+        if len(lines) < 2:
+            return {
+                'line_count': len(lines),
+                'average_spacing': 0,
+                'spacing_std': 0,
+                'line_positions': lines,
+                'spacing_values': []
+            }
+        
+        # Calcola lo spazio tra le linee consecutive
+        spacing = [lines[i+1] - lines[i] for i in range(len(lines)-1)]
+        
+        return {
+            'line_count': len(lines),
+            'average_spacing': np.mean(spacing),
+            'spacing_std': np.std(spacing),
+            'line_positions': lines,
+            'spacing_values': spacing
+        }
+    
+    def detect_word_boundaries(self, image, line_positions=None):
+        """
+        Rileva i confini delle parole in un'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            line_positions (list, optional): Posizioni y delle linee di testo
+            
+        Returns:
+            list: Lista di tuple (linea, x_inizio, x_fine) per ogni parola
+        """
+        # Converti in scala di grigi se necessario
+        if len(image.shape) > 2:
+            gray = self.preprocessor.convert_to_grayscale(image)
+        else:
+            gray = image
+        
+        # Binarizza l'immagine
+        binary = self.preprocessor.threshold_image(gray, method='adaptive')
+        
+        # Se non sono fornite le posizioni delle linee, rilevale
+        if line_positions is None:
+            line_positions = self.detect_lines(binary)
+        
+        # Se non ci sono linee, restituisci una lista vuota
+        if not line_positions:
+            return []
+        
+        # Calcola l'altezza media delle linee
+        line_height = 30  # Valore predefinito
+        if len(line_positions) > 1:
+            line_height = int(np.mean([line_positions[i+1] - line_positions[i] 
+                                      for i in range(len(line_positions)-1)]))
+        
+        # Rileva le parole per ogni linea
+        words = []
+        for i, y in enumerate(line_positions):
+            # Estrai una regione intorno alla linea
+            y_start = max(0, y - line_height // 2)
+            y_end = min(binary.shape[0], y + line_height // 2)
+            line_region = binary[y_start:y_end, :]
+            
+            # Proiezione verticale (somma i pixel bianchi per ogni colonna)
+            projection = np.sum(line_region, axis=0)
+            
+            # Normalizza la proiezione
+            if np.max(projection) > 0:
+                projection = projection / np.max(projection)
+            
+            # Trova i confini delle parole
+            threshold = 0.1  # Soglia per considerare uno spazio
+            in_word = False
+            start_word = 0
+            
+            for j in range(len(projection)):
+                if projection[j] > threshold and not in_word:
+                    in_word = True
+                    start_word = j
+                elif projection[j] <= threshold and in_word:
+                    in_word = False
+                    words.append((i, start_word, j))
+            
+            # Se l'ultima parola non è stata chiusa
+            if in_word:
+                words.append((i, start_word, len(projection) - 1))
+        
+        return words
+    
+    def measure_word_spacing(self, image):
+        """
+        Misura lo spazio tra le parole.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            
+        Returns:
+            dict: Informazioni sullo spazio tra le parole
+        """
+        # Rileva le linee
+        lines = self.detect_lines(image)
+        
+        # Rileva i confini delle parole
+        words = self.detect_word_boundaries(image, lines)
+        
+        # Calcola lo spazio tra le parole consecutive sulla stessa linea
+        spacing = []
+        for i in range(len(words)-1):
+            line1, _, end1 = words[i]
+            line2, start2, _ = words[i+1]
+            
+            # Considera solo le parole sulla stessa linea
+            if line1 == line2:
+                space = start2 - end1
+                if space > 0:  # Ignora sovrapposizioni
+                    spacing.append(space)
+        
+        if not spacing:
+            return {
+                'word_count': len(words),
+                'average_spacing': 0,
+                'spacing_std': 0,
+                'spacing_values': []
+            }
+        
+        return {
+            'word_count': len(words),
+            'average_spacing': np.mean(spacing),
+            'spacing_std': np.std(spacing),
+            'spacing_values': spacing
+        }
+    
+    def detect_margins(self, image):
+        """
+        Rileva i margini del documento.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            
+        Returns:
+            dict: Informazioni sui margini (sinistra, destra, superiore, inferiore)
+        """
+        # Converti in scala di grigi se necessario
+        if len(image.shape) > 2:
+            gray = self.preprocessor.convert_to_grayscale(image)
+        else:
+            gray = image
+        
+        # Binarizza l'immagine
+        binary = self.preprocessor.threshold_image(gray, method='adaptive')
+        
+        # Inverti l'immagine (testo bianco su sfondo nero)
+        binary_inv = cv2.bitwise_not(binary)
+        
+        # Proiezione orizzontale (somma i pixel bianchi per ogni riga)
+        h_projection = np.sum(binary_inv, axis=1)
+        
+        # Proiezione verticale (somma i pixel bianchi per ogni colonna)
+        v_projection = np.sum(binary_inv, axis=0)
+        
+        # Normalizza le proiezioni
+        if np.max(h_projection) > 0:
+            h_projection = h_projection / np.max(h_projection)
+        if np.max(v_projection) > 0:
+            v_projection = v_projection / np.max(v_projection)
+        
+        # Trova i margini
+        threshold = 0.05  # Soglia per considerare un margine
+        
+        # Margine superiore
+        top_margin = 0
+        while top_margin < len(h_projection) and h_projection[top_margin] <= threshold:
+            top_margin += 1
+        
+        # Margine inferiore
+        bottom_margin = len(h_projection) - 1
+        while bottom_margin >= 0 and h_projection[bottom_margin] <= threshold:
+            bottom_margin -= 1
+        bottom_margin = len(h_projection) - 1 - bottom_margin
+        
+        # Margine sinistro
+        left_margin = 0
+        while left_margin < len(v_projection) and v_projection[left_margin] <= threshold:
+            left_margin += 1
+        
+        # Margine destro
+        right_margin = len(v_projection) - 1
+        while right_margin >= 0 and v_projection[right_margin] <= threshold:
+            right_margin -= 1
+        right_margin = len(v_projection) - 1 - right_margin
+        
+        return {
+            'top': top_margin,
+            'bottom': bottom_margin,
+            'left': left_margin,
+            'right': right_margin
+        }
+    
+    def measure_character_slant(self, image):
+        """
+        Misura l'inclinazione dei caratteri.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            
+        Returns:
+            dict: Informazioni sull'inclinazione dei caratteri
+        """
+        # Converti in scala di grigi se necessario
+        if len(image.shape) > 2:
+            gray = self.preprocessor.convert_to_grayscale(image)
+        else:
+            gray = image
+        
+        # Binarizza l'immagine
+        binary = self.preprocessor.threshold_image(gray, method='adaptive')
+        
+        # Applica la trasformata di Hough probabilistica
+        edges = cv2.Canny(binary, 50, 150, apertureSize=3)
+        lines = cv2.HoughLinesP(edges, 1, np.pi/180, threshold=50, minLineLength=15, maxLineGap=10)
+        
+        if lines is None:
+            return {
+                'average_slant': 0,
+                'slant_std': 0,
+                'slant_values': []
+            }
+        
+        # Calcola l'angolo di inclinazione per ogni linea
+        angles = []
+        for line in lines:
+            x1, y1, x2, y2 = line[0]
+            
+            # Ignora le linee orizzontali
+            if abs(x2 - x1) > 5:
+                # Calcola l'angolo in gradi
+                angle = np.arctan2(y2 - y1, x2 - x1) * 180 / np.pi
+                
+                # Considera solo gli angoli tra -45 e 45 gradi (caratteri inclinati)
+                if -45 <= angle <= 45:
+                    angles.append(angle)
+        
+        if not angles:
+            return {
+                'average_slant': 0,
+                'slant_std': 0,
+                'slant_values': []
+            }
+        
+        return {
+            'average_slant': np.mean(angles),
+            'slant_std': np.std(angles),
+            'slant_values': angles
+        }
+    
+    def analyze_pressure_profile(self, image):
+        """
+        Analizza il profilo di pressione in un'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            
+        Returns:
+            dict: Informazioni sul profilo di pressione
+        """
+        # Converti in scala di grigi se necessario
+        if len(image.shape) > 2:
+            gray = self.preprocessor.convert_to_grayscale(image)
+        else:
+            gray = image
+        
+        # Inverti l'immagine (testo bianco su sfondo nero)
+        gray_inv = cv2.bitwise_not(gray)
+        
+        # Applica una soglia per isolare il testo
+        _, binary = cv2.threshold(gray_inv, 50, 255, cv2.THRESH_BINARY)
+        
+        # Calcola l'intensità media dei pixel di testo
+        text_pixels = gray_inv[binary > 0]
+        
+        if len(text_pixels) == 0:
+            return {
+                'average_pressure': 0,
+                'pressure_std': 0,
+                'pressure_histogram': None
+            }
+        
+        # Calcola l'istogramma dell'intensità
+        hist, bins = np.histogram(text_pixels, bins=50, range=(0, 255))
+        
+        # Normalizza l'istogramma
+        hist = hist / np.sum(hist)
+        
+        # Calcola la pressione media (intensità media)
+        average_pressure = np.mean(text_pixels)
+        
+        # Calcola la deviazione standard della pressione
+        pressure_std = np.std(text_pixels)
+        
+        return {
+            'average_pressure': float(average_pressure),
+            'pressure_std': float(pressure_std),
+            'pressure_histogram': {
+                'hist': hist.tolist(),
+                'bins': bins.tolist()
+            }
+        }
+    
+    def generate_measurement_report(self, image):
+        """
+        Genera un report completo di misurazione per un'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            
+        Returns:
+            dict: Report completo di misurazione
+        """
+        # Carica l'immagine se è un percorso file
+        if isinstance(image, str):
+            image = self.preprocessor.load_image(image)
+        
+        # Misura lo spazio tra le linee
+        line_spacing = self.measure_line_spacing(image)
+        
+        # Misura lo spazio tra le parole
+        word_spacing = self.measure_word_spacing(image)
+        
+        # Rileva i margini
+        margins = self.detect_margins(image)
+        
+        # Misura l'inclinazione dei caratteri
+        slant = self.measure_character_slant(image)
+        
+        # Analizza il profilo di pressione
+        pressure = self.analyze_pressure_profile(image)
+        
+        return {
+            'line_spacing': line_spacing,
+            'word_spacing': word_spacing,
+            'margins': margins,
+            'character_slant': slant,
+            'pressure_profile': pressure
+        }
+    
+    def visualize_measurements(self, image, measurements, save_path=None):
+        """
+        Visualizza le misurazioni su un'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            measurements (dict): Risultato di generate_measurement_report
+            save_path (str, optional): Percorso dove salvare l'immagine
+            
+        Returns:
+            matplotlib.figure.Figure: Figura con la visualizzazione
+        """
+        # Crea una copia dell'immagine per la visualizzazione
+        if len(image.shape) == 2:
+            # Converti in BGR se è in scala di grigi
+            vis_image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
+        else:
+            vis_image = image.copy()
+        
+        # Converti in RGB per matplotlib
+        vis_image_rgb = cv2.cvtColor(vis_image, cv2.COLOR_BGR2RGB)
+        
+        # Crea una figura con più sottografici
+        fig, axs = plt.subplots(2, 2, figsize=(15, 12))
+        
+        # Immagine con linee di testo
+        axs[0, 0].imshow(vis_image_rgb)
+        axs[0, 0].set_title('Linee di Testo e Margini')
+        
+        # Disegna le linee di testo
+        for y in measurements['line_spacing']['line_positions']:
+            axs[0, 0].axhline(y=y, color='r', linestyle='-', alpha=0.5)
+        
+        # Disegna i margini
+        margins = measurements['margins']
+        h, w = image.shape[:2]
+        
+        # Margine superiore
+        axs[0, 0].axhline(y=margins['top'], color='g', linestyle='--')
+        # Margine inferiore
+        axs[0, 0].axhline(y=h - margins['bottom'], color='g', linestyle='--')
+        # Margine sinistro
+        axs[0, 0].axvline(x=margins['left'], color='g', linestyle='--')
+        # Margine destro
+        axs[0, 0].axvline(x=w - margins['right'], color='g', linestyle='--')
+        
+        axs[0, 0].axis('off')
+        
+        # Grafico dell'inclinazione dei caratteri
+        if measurements['character_slant']['slant_values']:
+            axs[0, 1].hist(measurements['character_slant']['slant_values'], bins=20, 
+                          range=(-45, 45), color='blue', alpha=0.7)
+            axs[0, 1].axvline(x=measurements['character_slant']['average_slant'], 
+                             color='r', linestyle='-', linewidth=2)
+            axs[0, 1].set_title(f"Inclinazione dei Caratteri: {measurements['character_slant']['average_slant']:.1f}°")
+            axs[0, 1].set_xlabel('Angolo (gradi)')
+            axs[0, 1].set_ylabel('Frequenza')
+        else:
+            axs[0, 1].text(0.5, 0.5, 'Dati di inclinazione non disponibili', 
+                          horizontalalignment='center', verticalalignment='center')
+            axs[0, 1].set_title('Inclinazione dei Caratteri')
+        
+        # Grafico del profilo di pressione
+        if measurements['pressure_profile']['pressure_histogram'] is not None:
+            hist = measurements['pressure_profile']['pressure_histogram']['hist']
+            bins = measurements['pressure_profile']['pressure_histogram']['bins']
+            bin_centers = 0.5 * (bins[:-1] + bins[1:])
+            
+            axs[1, 0].bar(bin_centers, hist, width=bins[1] - bins[0], color='green', alpha=0.7)
+            axs[1, 0].axvline(x=measurements['pressure_profile']['average_pressure'], 
+                             color='r', linestyle='-', linewidth=2)
+            axs[1, 0].set_title(f"Profilo di Pressione: {measurements['pressure_profile']['average_pressure']:.1f}")
+            axs[1, 0].set_xlabel('Intensità')
+            axs[1, 0].set_ylabel('Frequenza Normalizzata')
+        else:
+            axs[1, 0].text(0.5, 0.5, 'Dati di pressione non disponibili', 
+                          horizontalalignment='center', verticalalignment='center')
+            axs[1, 0].set_title('Profilo di Pressione')
+        
+        # Tabella con le misurazioni
+        axs[1, 1].axis('tight')
+        axs[1, 1].axis('off')
+        
+        table_data = [
+            ['Metrica', 'Valore'],
+            ['Numero di Linee', f"{measurements['line_spacing']['line_count']}"],
+            ['Spazio Medio tra Linee', f"{measurements['line_spacing']['average_spacing']:.1f} px"],
+            ['Numero di Parole', f"{measurements['word_spacing']['word_count']}"],
+            ['Spazio Medio tra Parole', f"{measurements['word_spacing']['average_spacing']:.1f} px"],
+            ['Margine Superiore', f"{margins['top']} px"],
+            ['Margine Inferiore', f"{margins['bottom']} px"],
+            ['Margine Sinistro', f"{margins['left']} px"],
+            ['Margine Destro', f"{margins['right']} px"],
+            ['Inclinazione Media', f"{measurements['character_slant']['average_slant']:.1f}°"],
+            ['Pressione Media', f"{measurements['pressure_profile']['average_pressure']:.1f}"]
+        ]
+        
+        table = axs[1, 1].table(cellText=table_data, loc='center', cellLoc='center')
+        table.auto_set_font_size(False)
+        table.set_fontsize(10)
+        table.scale(1, 1.5)
+        axs[1, 1].set_title('Riepilogo Misurazioni')
+        
+        plt.tight_layout()
+        
+        # Salva l'immagine se richiesto
+        if save_path:
+            plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        
+        return fig
+    
+    def create_digital_ruler(self, image, dpi=96, save_path=None):
+        """
+        Crea un righello digitale sovrapposto all'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            dpi (int): Punti per pollice (per la conversione in unità fisiche)
+            save_path (str, optional): Percorso dove salvare l'immagine
+            
+        Returns:
+            numpy.ndarray: Immagine con righello sovrapposto
+        """
+        # Crea una copia dell'immagine per la visualizzazione
+        if len(image.shape) == 2:
+            # Converti in BGR se è in scala di grigi
+            vis_image = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
+        else:
+            vis_image = image.copy()
+        
+        # Dimensioni dell'immagine
+        h, w = image.shape[:2]
+        
+        # Calcola la scala (pixel per millimetro)
+        pixels_per_mm = dpi / 25.4  # 25.4 mm = 1 pollice
+        
+        # Disegna il righello orizzontale
+        y_ruler = 30  # Posizione y del righello orizzontale
+        
+        # Disegna la linea principale
+        cv2.line(vis_image, (0, y_ruler), (w, y_ruler), (0, 0, 255), 2)
+        
+        # Disegna le tacche principali (ogni 10 mm)
+        for x in range(0, w, int(10 * pixels_per_mm)):
+            cv2.line(vis_image, (x, y_ruler - 10), (x, y_ruler + 10), (0, 0, 255), 2)
+            # Aggiungi l'etichetta (in mm)
+            label = f"{int(x / pixels_per_mm)}"
+            cv2.putText(vis_image, label, (x - 10, y_ruler - 15), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
+        
+        # Disegna le tacche secondarie (ogni 1 mm)
+        for x in range(0, w, int(1 * pixels_per_mm)):
+            cv2.line(vis_image, (x, y_ruler - 5), (x, y_ruler + 5), (0, 0, 255), 1)
+        
+        # Disegna il righello verticale
+        x_ruler = 30  # Posizione x del righello verticale
+        
+        # Disegna la linea principale
+        cv2.line(vis_image, (x_ruler, 0), (x_ruler, h), (0, 0, 255), 2)
+        
+        # Disegna le tacche principali (ogni 10 mm)
+        for y in range(0, h, int(10 * pixels_per_mm)):
+            cv2.line(vis_image, (x_ruler - 10, y), (x_ruler + 10, y), (0, 0, 255), 2)
+            # Aggiungi l'etichetta (in mm)
+            label = f"{int(y / pixels_per_mm)}"
+            cv2.putText(vis_image, label, (x_ruler - 30, y + 5), 
+                       cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 255), 1)
+        
+        # Disegna le tacche secondarie (ogni 1 mm)
+        for y in range(0, h, int(1 * pixels_per_mm)):
+            cv2.line(vis_image, (x_ruler - 5, y), (x_ruler + 5, y), (0, 0, 255), 1)
+        
+        # Aggiungi informazioni sulla scala
+        scale_info = f"Scala: 1 pixel = {1/pixels_per_mm:.3f} mm (DPI: {dpi})"
+        cv2.putText(vis_image, scale_info, (w - 300, h - 20), 
+                   cv2.FONT_HERSHEY_SIMPLEX, 0.6, (0, 0, 255), 1)
+        
+        # Salva l'immagine se richiesto
+        if save_path:
+            cv2.imwrite(save_path, vis_image)
+        
+        return vis_image

src/ml_models.py

@@ -0,0 +1,711 @@
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from sklearn.ensemble import IsolationForest
+from sklearn.preprocessing import StandardScaler
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+import cv2
+import os
+import pickle
+import joblib
+
+from .preprocessing import ImagePreprocessor
+from .signature_analysis import SignatureAnalyzer
+
+
+class SignatureFeatureExtractor:
+    """
+    Classe per estrarre caratteristiche dalle firme da utilizzare nei modelli di machine learning.
+    """
+    
+    def __init__(self):
+        """Inizializza l'estrattore di caratteristiche."""
+        self.preprocessor = ImagePreprocessor()
+        self.analyzer = SignatureAnalyzer()
+    
+    def extract_features(self, image_path):
+        """
+        Estrae un vettore di caratteristiche da un'immagine di firma.
+        
+        Args:
+            image_path (str): Percorso dell'immagine della firma
+            
+        Returns:
+            dict: Dizionario di caratteristiche
+        """
+        # Pre-elabora la firma
+        processed = self.preprocessor.preprocess_signature(image_path)
+        
+        # Estrai metriche grafometriche
+        metrics = self.analyzer.extract_signature_metrics(processed['binary'])
+        
+        # Estrai caratteristiche ORB
+        keypoints, descriptors = self.analyzer.extract_features_orb(processed['binary'])
+        
+        # Se non ci sono descrittori, restituisci un vettore di zeri
+        if descriptors is None:
+            orb_features = np.zeros(32)
+        else:
+            # Calcola la media dei descrittori per ottenere un vettore di caratteristiche fisso
+            orb_features = np.mean(descriptors, axis=0) if descriptors.shape[0] > 0 else np.zeros(32)
+        
+        # Calcola caratteristiche aggiuntive dall'immagine binaria
+        binary = processed['binary']
+        
+        # Calcola il numero di componenti connessi (tratti separati)
+        num_labels, labels = cv2.connectedComponents(binary)
+        
+        # Calcola il rapporto tra pixel bianchi e neri
+        white_pixels = cv2.countNonZero(binary)
+        total_pixels = binary.shape[0] * binary.shape[1]
+        black_pixels = total_pixels - white_pixels
+        white_black_ratio = white_pixels / black_pixels if black_pixels > 0 else 0
+        
+        # Calcola la densità dei pixel (percentuale di pixel bianchi)
+        density = white_pixels / total_pixels
+        
+        # Calcola il centro di massa
+        y_indices, x_indices = np.where(binary > 0)
+        if len(x_indices) > 0 and len(y_indices) > 0:
+            center_x = np.mean(x_indices)
+            center_y = np.mean(y_indices)
+        else:
+            center_x = 0
+            center_y = 0
+        
+        # Normalizza il centro di massa rispetto alle dimensioni dell'immagine
+        norm_center_x = center_x / binary.shape[1] if binary.shape[1] > 0 else 0
+        norm_center_y = center_y / binary.shape[0] if binary.shape[0] > 0 else 0
+        
+        # Calcola momenti di Hu (invarianti alla rotazione, scala e traslazione)
+        moments = cv2.moments(binary)
+        hu_moments = cv2.HuMoments(moments).flatten()
+        
+        # Logaritmo dei momenti di Hu per gestire meglio i valori molto piccoli
+        hu_moments = -np.sign(hu_moments) * np.log10(np.abs(hu_moments) + 1e-10)
+        
+        # Combina tutte le caratteristiche in un dizionario
+        features = {
+            # Metriche grafometriche
+            'area': metrics['area'],
+            'perimeter': metrics['perimeter'],
+            'width': metrics['width'],
+            'height': metrics['height'],
+            'aspect_ratio': metrics['aspect_ratio'],
+            'density': metrics['density'],
+            'slant_angle': metrics['slant_angle'],
+            
+            # Caratteristiche aggiuntive
+            'num_components': num_labels - 1,  # -1 perché lo sfondo è contato come componente
+            'white_black_ratio': white_black_ratio,
+            'pixel_density': density,
+            'center_x_norm': norm_center_x,
+            'center_y_norm': norm_center_y,
+            
+            # Momenti di Hu
+            'hu1': hu_moments[0],
+            'hu2': hu_moments[1],
+            'hu3': hu_moments[2],
+            'hu4': hu_moments[3],
+            'hu5': hu_moments[4],
+            'hu6': hu_moments[5],
+            'hu7': hu_moments[6],
+        }
+        
+        # Aggiungi le caratteristiche ORB
+        for i, val in enumerate(orb_features):
+            features[f'orb_{i}'] = float(val)
+        
+        return features
+    
+    def extract_features_batch(self, image_paths):
+        """
+        Estrae caratteristiche da un batch di immagini di firme.
+        
+        Args:
+            image_paths (list): Lista di percorsi delle immagini
+            
+        Returns:
+            pandas.DataFrame: DataFrame con le caratteristiche estratte
+        """
+        features_list = []
+        
+        for path in image_paths:
+            try:
+                features = self.extract_features(path)
+                features['image_path'] = path
+                features_list.append(features)
+            except Exception as e:
+                print(f"Errore nell'estrazione delle caratteristiche da {path}: {e}")
+        
+        return pd.DataFrame(features_list)
+
+
+class AnomalyDetector:
+    """
+    Classe per il rilevamento di anomalie nelle firme utilizzando Isolation Forest.
+    """
+    
+    def __init__(self, contamination=0.1, random_state=42):
+        """
+        Inizializza il rilevatore di anomalie.
+        
+        Args:
+            contamination (float): Percentuale attesa di outlier nei dati
+            random_state (int): Seed per la riproducibilità
+        """
+        self.model = IsolationForest(contamination=contamination, random_state=random_state)
+        self.scaler = StandardScaler()
+        self.feature_extractor = SignatureFeatureExtractor()
+        self.is_fitted = False
+    
+    def fit(self, signatures_df=None, signatures_paths=None):
+        """
+        Addestra il modello di rilevamento anomalie.
+        
+        Args:
+            signatures_df (pandas.DataFrame, optional): DataFrame con le caratteristiche estratte
+            signatures_paths (list, optional): Lista di percorsi delle immagini di firme autentiche
+            
+        Returns:
+            self: Istanza addestrata
+        """
+        if signatures_df is None and signatures_paths is None:
+            raise ValueError("È necessario fornire o un DataFrame di caratteristiche o una lista di percorsi di immagini")
+        
+        if signatures_df is None:
+            # Estrai caratteristiche dalle immagini
+            signatures_df = self.feature_extractor.extract_features_batch(signatures_paths)
+        
+        # Rimuovi colonne non numeriche
+        features_df = signatures_df.select_dtypes(include=['number'])
+        
+        # Normalizza le caratteristiche
+        X = self.scaler.fit_transform(features_df)
+        
+        # Addestra il modello
+        self.model.fit(X)
+        self.is_fitted = True
+        
+        # Salva le colonne utilizzate
+        self.feature_columns = features_df.columns.tolist()
+        
+        return self
+    
+    def predict(self, signature_path=None, features=None):
+        """
+        Predice se una firma è anomala.
+        
+        Args:
+            signature_path (str, optional): Percorso dell'immagine della firma
+            features (dict, optional): Caratteristiche già estratte
+            
+        Returns:
+            dict: Risultato della predizione
+        """
+        if not self.is_fitted:
+            raise ValueError("Il modello deve essere addestrato prima di fare predizioni")
+        
+        if signature_path is None and features is None:
+            raise ValueError("È necessario fornire o un percorso di immagine o le caratteristiche estratte")
+        
+        if features is None:
+            # Estrai caratteristiche dall'immagine
+            features = self.feature_extractor.extract_features(signature_path)
+        
+        # Crea un DataFrame con le caratteristiche
+        features_df = pd.DataFrame([features])
+        
+        # Seleziona solo le colonne utilizzate durante l'addestramento
+        features_df = features_df[self.feature_columns]
+        
+        # Normalizza le caratteristiche
+        X = self.scaler.transform(features_df)
+        
+        # Predici l'anomalia
+        # -1 per outlier (anomalia), 1 per inlier (normale)
+        prediction = self.model.predict(X)[0]
+        
+        # Calcola il punteggio di anomalia
+        # Più negativo è il punteggio, più anomala è la firma
+        score = self.model.decision_function(X)[0]
+        
+        # Converti il punteggio in un valore percentuale
+        # 0% = molto anomalo, 100% = normale
+        normalized_score = (score + 0.5) / 1.0  # Adatta in base ai tuoi dati
+        normalized_score = max(0, min(1, normalized_score)) * 100
+        
+        return {
+            'is_anomaly': prediction == -1,
+            'anomaly_score': score,
+            'confidence': normalized_score,
+            'prediction': 'anomaly' if prediction == -1 else 'normal'
+        }
+    
+    def save_model(self, model_path, scaler_path=None):
+        """
+        Salva il modello addestrato.
+        
+        Args:
+            model_path (str): Percorso dove salvare il modello
+            scaler_path (str, optional): Percorso dove salvare lo scaler
+        """
+        if not self.is_fitted:
+            raise ValueError("Il modello deve essere addestrato prima di essere salvato")
+        
+        # Salva il modello
+        joblib.dump(self.model, model_path)
+        
+        # Salva lo scaler se specificato
+        if scaler_path:
+            joblib.dump(self.scaler, scaler_path)
+        
+        # Salva anche le colonne delle caratteristiche
+        metadata = {
+            'feature_columns': self.feature_columns
+        }
+        
+        # Salva i metadati
+        metadata_path = os.path.splitext(model_path)[0] + '_metadata.pkl'
+        with open(metadata_path, 'wb') as f:
+            pickle.dump(metadata, f)
+    
+    def load_model(self, model_path, scaler_path=None):
+        """
+        Carica un modello addestrato.
+        
+        Args:
+            model_path (str): Percorso del modello salvato
+            scaler_path (str, optional): Percorso dello scaler salvato
+        """
+        # Carica il modello
+        self.model = joblib.load(model_path)
+        
+        # Carica lo scaler se specificato
+        if scaler_path:
+            self.scaler = joblib.load(scaler_path)
+        
+        # Carica i metadati
+        metadata_path = os.path.splitext(model_path)[0] + '_metadata.pkl'
+        if os.path.exists(metadata_path):
+            with open(metadata_path, 'rb') as f:
+                metadata = pickle.load(f)
+            self.feature_columns = metadata['feature_columns']
+        
+        self.is_fitted = True
+
+
+class SignatureDataset(Dataset):
+    """
+    Dataset PyTorch per le immagini di firme.
+    """
+    
+    def __init__(self, image_paths, labels=None, transform=None, target_size=(128, 128)):
+        """
+        Inizializza il dataset.
+        
+        Args:
+            image_paths (list): Lista di percorsi delle immagini
+            labels (list, optional): Lista di etichette (1 per autentico, 0 per falso)
+            transform (callable, optional): Trasformazioni da applicare alle immagini
+            target_size (tuple): Dimensione target per le immagini
+        """
+        self.image_paths = image_paths
+        self.labels = labels
+        self.transform = transform
+        self.target_size = target_size
+        self.preprocessor = ImagePreprocessor()
+    
+    def __len__(self):
+        return len(self.image_paths)
+    
+    def __getitem__(self, idx):
+        # Carica l'immagine
+        image = self.preprocessor.load_image(self.image_paths[idx])
+        
+        # Pre-elabora l'immagine
+        image = self.preprocessor.convert_to_grayscale(image)
+        image = self.preprocessor.normalize_image(image)
+        
+        # Ridimensiona l'immagine
+        image = cv2.resize(image, self.target_size)
+        
+        # Normalizza i valori dei pixel nell'intervallo [0, 1]
+        image = image.astype(np.float32) / 255.0
+        
+        # Aggiungi una dimensione per il canale (1 canale per immagini in scala di grigi)
+        image = np.expand_dims(image, axis=0)
+        
+        # Converti in tensore PyTorch
+        image = torch.from_numpy(image)
+        
+        # Applica trasformazioni se specificate
+        if self.transform:
+            image = self.transform(image)
+        
+        # Restituisci l'immagine e l'etichetta se disponibile
+        if self.labels is not None:
+            label = self.labels[idx]
+            return image, torch.tensor(label, dtype=torch.float32)
+        else:
+            return image
+
+
+class SiameseNetwork(nn.Module):
+    """
+    Rete siamese per la verifica delle firme.
+    """
+    
+    def __init__(self):
+        """Inizializza la rete siamese."""
+        super(SiameseNetwork, self).__init__()
+        
+        # CNN per l'estrazione delle caratteristiche
+        self.cnn = nn.Sequential(
+            # Prima convoluzione
+            nn.Conv2d(1, 64, kernel_size=10, stride=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2),
+            
+            # Seconda convoluzione
+            nn.Conv2d(64, 128, kernel_size=7, stride=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2),
+            
+            # Terza convoluzione
+            nn.Conv2d(128, 128, kernel_size=4, stride=1),
+            nn.ReLU(inplace=True),
+            nn.MaxPool2d(2),
+            
+            # Quarta convoluzione
+            nn.Conv2d(128, 256, kernel_size=4, stride=1),
+            nn.ReLU(inplace=True)
+        )
+        
+        # Fully connected per la classificazione
+        self.fc = nn.Sequential(
+            nn.Linear(256 * 9 * 9, 4096),
+            nn.Sigmoid()
+        )
+        
+        # Layer di output
+        self.output = nn.Sequential(
+            nn.Linear(4096, 1),
+            nn.Sigmoid()
+        )
+    
+    def forward_one(self, x):
+        """
+        Forward pass per una singola immagine.
+        
+        Args:
+            x (torch.Tensor): Immagine di input
+            
+        Returns:
+            torch.Tensor: Embedding dell'immagine
+        """
+        x = self.cnn(x)
+        x = x.view(x.size(0), -1)
+        x = self.fc(x)
+        return x
+    
+    def forward(self, input1, input2):
+        """
+        Forward pass per una coppia di immagini.
+        
+        Args:
+            input1 (torch.Tensor): Prima immagine
+            input2 (torch.Tensor): Seconda immagine
+            
+        Returns:
+            torch.Tensor: Probabilità che le firme siano della stessa persona
+        """
+        # Ottieni gli embedding per entrambe le immagini
+        output1 = self.forward_one(input1)
+        output2 = self.forward_one(input2)
+        
+        # Calcola la distanza euclidea
+        distance = torch.abs(output1 - output2)
+        
+        # Calcola la probabilità
+        prob = self.output(distance)
+        
+        return prob
+
+
+class SignatureVerifier:
+    """
+    Classe per la verifica delle firme utilizzando una rete siamese.
+    """
+    
+    def __init__(self, model_path=None):
+        """
+        Inizializza il verificatore di firme.
+        
+        Args:
+            model_path (str, optional): Percorso del modello pre-addestrato
+        """
+        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        self.model = SiameseNetwork().to(self.device)
+        self.preprocessor = ImagePreprocessor()
+        
+        if model_path and os.path.exists(model_path):
+            self.load_model(model_path)
+    
+    def train(self, genuine_paths, forged_paths, epochs=20, batch_size=32, learning_rate=0.0001):
+        """
+        Addestra la rete siamese.
+        
+        Args:
+            genuine_paths (list): Lista di percorsi delle firme autentiche
+            forged_paths (list): Lista di percorsi delle firme false
+            epochs (int): Numero di epoche di addestramento
+            batch_size (int): Dimensione del batch
+            learning_rate (float): Tasso di apprendimento
+            
+        Returns:
+            dict: Metriche di addestramento
+        """
+        # Crea coppie di immagini e etichette
+        pairs = []
+        labels = []
+        
+        # Coppie genuine (stessa persona)
+        for i in range(len(genuine_paths)):
+            for j in range(i + 1, len(genuine_paths)):
+                pairs.append((genuine_paths[i], genuine_paths[j]))
+                labels.append(1)  # 1 = stessa persona
+        
+        # Coppie false (persone diverse)
+        for genuine_path in genuine_paths:
+            for forged_path in forged_paths:
+                pairs.append((genuine_path, forged_path))
+                labels.append(0)  # 0 = persone diverse
+        
+        # Dividi in training e validation
+        train_pairs, val_pairs, train_labels, val_labels = train_test_split(
+            pairs, labels, test_size=0.2, random_state=42, stratify=labels
+        )
+        
+        # Crea i dataset
+        train_dataset = PairDataset(train_pairs, train_labels)
+        val_dataset = PairDataset(val_pairs, val_labels)
+        
+        # Crea i dataloader
+        train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
+        val_loader = DataLoader(val_dataset, batch_size=batch_size)
+        
+        # Definisci l'ottimizzatore e la funzione di perdita
+        optimizer = optim.Adam(self.model.parameters(), lr=learning_rate)
+        criterion = nn.BCELoss()
+        
+        # Addestra il modello
+        train_losses = []
+        val_losses = []
+        val_accuracies = []
+        
+        for epoch in range(epochs):
+            # Training
+            self.model.train()
+            train_loss = 0
+            
+            for batch_idx, (img1, img2, target) in enumerate(train_loader):
+                img1, img2, target = img1.to(self.device), img2.to(self.device), target.to(self.device)
+                
+                # Forward pass
+                output = self.model(img1, img2)
+                loss = criterion(output, target.view(-1, 1))
+                
+                # Backward pass
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                
+                train_loss += loss.item()
+            
+            train_loss /= len(train_loader)
+            train_losses.append(train_loss)
+            
+            # Validation
+            self.model.eval()
+            val_loss = 0
+            correct = 0
+            
+            with torch.no_grad():
+                for img1, img2, target in val_loader:
+                    img1, img2, target = img1.to(self.device), img2.to(self.device), target.to(self.device)
+                    
+                    # Forward pass
+                    output = self.model(img1, img2)
+                    val_loss += criterion(output, target.view(-1, 1)).item()
+                    
+                    # Calcola l'accuratezza
+                    pred = (output > 0.5).float()
+                    correct += pred.eq(target.view(-1, 1)).sum().item()
+            
+            val_loss /= len(val_loader)
+            val_losses.append(val_loss)
+            
+            val_accuracy = 100. * correct / len(val_dataset)
+            val_accuracies.append(val_accuracy)
+            
+            print(f'Epoch: {epoch+1}/{epochs}, Train Loss: {train_loss:.4f}, Val Loss: {val_loss:.4f}, Val Accuracy: {val_accuracy:.2f}%')
+        
+        return {
+            'train_losses': train_losses,
+            'val_losses': val_losses,
+            'val_accuracies': val_accuracies
+        }
+    
+    def verify(self, image_path1, image_path2):
+        """
+        Verifica se due firme sono della stessa persona.
+        
+        Args:
+            image_path1 (str): Percorso della prima immagine
+            image_path2 (str): Percorso della seconda immagine
+            
+        Returns:
+            dict: Risultato della verifica
+        """
+        self.model.eval()
+        
+        # Carica e pre-elabora le immagini
+        img1 = self._preprocess_image(image_path1)
+        img2 = self._preprocess_image(image_path2)
+        
+        # Converti in tensori PyTorch
+        img1 = torch.from_numpy(img1).unsqueeze(0).to(self.device)
+        img2 = torch.from_numpy(img2).unsqueeze(0).to(self.device)
+        
+        # Forward pass
+        with torch.no_grad():
+            output = self.model(img1, img2)
+        
+        # Calcola la probabilità
+        probability = output.item()
+        
+        return {
+            'is_same_person': probability > 0.5,
+            'probability': probability,
+            'confidence': probability * 100 if probability > 0.5 else (1 - probability) * 100
+        }
+    
+    def _preprocess_image(self, image_path, target_size=(128, 128)):
+        """
+        Pre-elabora un'immagine per la rete siamese.
+        
+        Args:
+            image_path (str): Percorso dell'immagine
+            target_size (tuple): Dimensione target
+            
+        Returns:
+            numpy.ndarray: Immagine pre-elaborata
+        """
+        # Carica l'immagine
+        image = self.preprocessor.load_image(image_path)
+        
+        # Pre-elabora l'immagine
+        image = self.preprocessor.convert_to_grayscale(image)
+        image = self.preprocessor.normalize_image(image)
+        
+        # Ridimensiona l'immagine
+        image = cv2.resize(image, target_size)
+        
+        # Normalizza i valori dei pixel nell'intervallo [0, 1]
+        image = image.astype(np.float32) / 255.0
+        
+        # Aggiungi una dimensione per il canale (1 canale per immagini in scala di grigi)
+        image = np.expand_dims(image, axis=0)
+        
+        return image
+    
+    def save_model(self, model_path):
+        """
+        Salva il modello addestrato.
+        
+        Args:
+            model_path (str): Percorso dove salvare il modello
+        """
+        torch.save(self.model.state_dict(), model_path)
+    
+    def load_model(self, model_path):
+        """
+        Carica un modello pre-addestrato.
+        
+        Args:
+            model_path (str): Percorso del modello salvato
+        """
+        self.model.load_state_dict(torch.load(model_path, map_location=self.device))
+        self.model.eval()
+
+
+class PairDataset(Dataset):
+    """
+    Dataset PyTorch per coppie di immagini di firme.
+    """
+    
+    def __init__(self, pairs, labels, target_size=(128, 128)):
+        """
+        Inizializza il dataset.
+        
+        Args:
+            pairs (list): Lista di coppie di percorsi di immagini
+            labels (list): Lista di etichette (1 per stessa persona, 0 per persone diverse)
+            target_size (tuple): Dimensione target per le immagini
+        """
+        self.pairs = pairs
+        self.labels = labels
+        self.target_size = target_size
+        self.preprocessor = ImagePreprocessor()
+    
+    def __len__(self):
+        return len(self.pairs)
+    
+    def __getitem__(self, idx):
+        # Carica la prima immagine
+        img1_path, img2_path = self.pairs[idx]
+        
+        # Pre-elabora le immagini
+        img1 = self._preprocess_image(img1_path)
+        img2 = self._preprocess_image(img2_path)
+        
+        # Converti in tensori PyTorch
+        img1 = torch.from_numpy(img1)
+        img2 = torch.from_numpy(img2)
+        
+        # Restituisci le immagini e l'etichetta
+        return img1, img2, self.labels[idx]
+    
+    def _preprocess_image(self, image_path):
+        """
+        Pre-elabora un'immagine.
+        
+        Args:
+            image_path (str): Percorso dell'immagine
+            
+        Returns:
+            numpy.ndarray: Immagine pre-elaborata
+        """
+        # Carica l'immagine
+        image = self.preprocessor.load_image(image_path)
+        
+        # Pre-elabora l'immagine
+        image = self.preprocessor.convert_to_grayscale(image)
+        image = self.preprocessor.normalize_image(image)
+        
+        # Ridimensiona l'immagine
+        image = cv2.resize(image, self.target_size)
+        
+        # Normalizza i valori dei pixel nell'intervallo [0, 1]
+        image = image.astype(np.float32) / 255.0
+        
+        # Aggiungi una dimensione per il canale (1 canale per immagini in scala di grigi)
+        image = np.expand_dims(image, axis=0)
+        
+        return image

src/preprocessing.py

@@ -0,0 +1,274 @@
+import cv2
+import numpy as np
+import os
+from PIL import Image
+import fitz  # PyMuPDF
+
+class ImagePreprocessor:
+    """
+    Classe per l'acquisizione e pre-elaborazione delle immagini di firme e documenti.
+    Implementa funzionalità di base come la conversione in scala di grigi,
+    normalizzazione, scontorno dei timbri, ecc.
+    """
+    
+    def __init__(self):
+        """Inizializza il preprocessore di immagini."""
+        pass
+    
+    def load_image(self, image_path):
+        """
+        Carica un'immagine da un percorso file.
+        
+        Args:
+            image_path (str): Percorso dell'immagine da caricare
+            
+        Returns:
+            numpy.ndarray: Immagine caricata in formato BGR
+        """
+        if not os.path.exists(image_path):
+            raise FileNotFoundError(f"Il file {image_path} non esiste")
+        
+        # Controlla l'estensione del file
+        _, ext = os.path.splitext(image_path)
+        ext = ext.lower()
+        
+        if ext == '.pdf':
+            return self.extract_image_from_pdf(image_path)
+        else:
+            # Carica l'immagine usando OpenCV
+            image = cv2.imread(image_path)
+            if image is None:
+                raise ValueError(f"Impossibile caricare l'immagine {image_path}")
+            return image
+    
+    def extract_image_from_pdf(self, pdf_path, page_num=0):
+        """
+        Estrae un'immagine da un file PDF.
+        
+        Args:
+            pdf_path (str): Percorso del file PDF
+            page_num (int): Numero di pagina da cui estrarre l'immagine (default: 0)
+            
+        Returns:
+            numpy.ndarray: Immagine estratta in formato BGR
+        """
+        # Apri il documento PDF
+        doc = fitz.open(pdf_path)
+        
+        # Controlla se il numero di pagina è valido
+        if page_num >= len(doc):
+            raise ValueError(f"Il PDF ha {len(doc)} pagine, ma è stata richiesta la pagina {page_num}")
+        
+        # Ottieni la pagina
+        page = doc.load_page(page_num)
+        
+        # Renderizza la pagina come immagine
+        pix = page.get_pixmap(matrix=fitz.Matrix(2, 2))  # Fattore di scala 2 per migliore qualità
+        
+        # Converti in formato immagine
+        img_data = pix.samples
+        
+        # Crea un array numpy dall'immagine
+        img_array = np.frombuffer(img_data, dtype=np.uint8).reshape(pix.height, pix.width, pix.n)
+        
+        # Se l'immagine è in formato RGB, converti in BGR per OpenCV
+        if pix.n == 3:
+            img_array = cv2.cvtColor(img_array, cv2.COLOR_RGB2BGR)
+        
+        return img_array
+    
+    def convert_to_grayscale(self, image):
+        """
+        Converte un'immagine in scala di grigi.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input in formato BGR
+            
+        Returns:
+            numpy.ndarray: Immagine in scala di grigi
+        """
+        if len(image.shape) == 2:
+            # L'immagine è già in scala di grigi
+            return image
+        
+        return cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    
+    def normalize_image(self, image):
+        """
+        Normalizza un'immagine per migliorare contrasto e luminosità.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input (scala di grigi o BGR)
+            
+        Returns:
+            numpy.ndarray: Immagine normalizzata
+        """
+        # Converti in scala di grigi se necessario
+        if len(image.shape) > 2:
+            gray = self.convert_to_grayscale(image)
+        else:
+            gray = image
+        
+        # Applica equalizzazione dell'istogramma
+        return cv2.equalizeHist(gray)
+    
+    def detect_and_extract_stamps(self, image, lower_color=None, upper_color=None):
+        """
+        Rileva e estrae i timbri da un'immagine utilizzando il filtraggio del colore.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input in formato BGR
+            lower_color (numpy.ndarray, optional): Limite inferiore del colore in formato HSV
+            upper_color (numpy.ndarray, optional): Limite superiore del colore in formato HSV
+            
+        Returns:
+            tuple: (immagine_originale_senza_timbri, maschera_timbri, timbri_estratti)
+        """
+        # Valori predefiniti per rilevare timbri blu (comuni nei documenti)
+        if lower_color is None:
+            lower_color = np.array([100, 50, 50])  # Blu in HSV
+        if upper_color is None:
+            upper_color = np.array([140, 255, 255])
+        
+        # Converti l'immagine in HSV
+        hsv = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
+        
+        # Crea una maschera per il colore specificato
+        mask = cv2.inRange(hsv, lower_color, upper_color)
+        
+        # Applica operazioni morfologiche per migliorare la maschera
+        kernel = np.ones((5, 5), np.uint8)
+        mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+        mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+        
+        # Estrai i timbri
+        stamps = cv2.bitwise_and(image, image, mask=mask)
+        
+        # Crea un'immagine senza timbri
+        inv_mask = cv2.bitwise_not(mask)
+        image_without_stamps = cv2.bitwise_and(image, image, mask=inv_mask)
+        
+        return image_without_stamps, mask, stamps
+    
+    def threshold_image(self, image, method='adaptive'):
+        """
+        Applica una soglia all'immagine per binarizzarla.
+        
+        Args:
+            image (numpy.ndarray): Immagine in scala di grigi
+            method (str): Metodo di soglia ('simple', 'adaptive', 'otsu')
+            
+        Returns:
+            numpy.ndarray: Immagine binaria
+        """
+        if len(image.shape) > 2:
+            gray = self.convert_to_grayscale(image)
+        else:
+            gray = image
+        
+        if method == 'simple':
+            _, binary = cv2.threshold(gray, 128, 255, cv2.THRESH_BINARY)
+        elif method == 'adaptive':
+            binary = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, 
+                                          cv2.THRESH_BINARY_INV, 11, 2)
+        elif method == 'otsu':
+            _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+        else:
+            raise ValueError(f"Metodo di soglia non supportato: {method}")
+        
+        return binary
+    
+    def resize_image(self, image, width=None, height=None, keep_aspect_ratio=True):
+        """
+        Ridimensiona un'immagine a una larghezza o altezza specificata.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            width (int, optional): Larghezza desiderata
+            height (int, optional): Altezza desiderata
+            keep_aspect_ratio (bool): Mantiene il rapporto d'aspetto originale
+            
+        Returns:
+            numpy.ndarray: Immagine ridimensionata
+        """
+        if width is None and height is None:
+            return image
+        
+        h, w = image.shape[:2]
+        
+        if keep_aspect_ratio:
+            if width is None:
+                aspect_ratio = height / float(h)
+                dim = (int(w * aspect_ratio), height)
+            else:
+                aspect_ratio = width / float(w)
+                dim = (width, int(h * aspect_ratio))
+        else:
+            dim = (width if width is not None else w, height if height is not None else h)
+        
+        return cv2.resize(image, dim, interpolation=cv2.INTER_AREA)
+    
+    def denoise_image(self, image, method='gaussian'):
+        """
+        Applica un filtro di riduzione del rumore all'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            method (str): Metodo di denoising ('gaussian', 'median', 'bilateral')
+            
+        Returns:
+            numpy.ndarray: Immagine filtrata
+        """
+        if method == 'gaussian':
+            return cv2.GaussianBlur(image, (5, 5), 0)
+        elif method == 'median':
+            return cv2.medianBlur(image, 5)
+        elif method == 'bilateral':
+            if len(image.shape) > 2:
+                return cv2.bilateralFilter(image, 9, 75, 75)
+            else:
+                # Per immagini in scala di grigi, convertiamo temporaneamente in BGR
+                temp = cv2.cvtColor(image, cv2.COLOR_GRAY2BGR)
+                temp = cv2.bilateralFilter(temp, 9, 75, 75)
+                return cv2.cvtColor(temp, cv2.COLOR_BGR2GRAY)
+        else:
+            raise ValueError(f"Metodo di denoising non supportato: {method}")
+    
+    def preprocess_signature(self, image_path, resize_width=800):
+        """
+        Pipeline completa di pre-elaborazione per le firme.
+        
+        Args:
+            image_path (str): Percorso dell'immagine della firma
+            resize_width (int): Larghezza a cui ridimensionare l'immagine
+            
+        Returns:
+            dict: Dizionario contenente le diverse fasi di pre-elaborazione
+        """
+        # Carica l'immagine
+        original = self.load_image(image_path)
+        
+        # Ridimensiona l'immagine
+        resized = self.resize_image(original, width=resize_width)
+        
+        # Converti in scala di grigi
+        gray = self.convert_to_grayscale(resized)
+        
+        # Normalizza l'immagine
+        normalized = self.normalize_image(gray)
+        
+        # Applica denoising
+        denoised = self.denoise_image(normalized, method='bilateral')
+        
+        # Applica soglia
+        binary = self.threshold_image(denoised, method='adaptive')
+        
+        # Restituisci tutte le fasi di pre-elaborazione
+        return {
+            'original': original,
+            'resized': resized,
+            'grayscale': gray,
+            'normalized': normalized,
+            'denoised': denoised,
+            'binary': binary
+        }

src/rag_system.py

@@ -0,0 +1,799 @@
+import os
+import re
+import fitz  # PyMuPDF
+import docx
+import pptx
+import numpy as np
+import pandas as pd
+import chromadb
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.vectorstores import Chroma
+from langchain.schema import Document
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
+from langchain.llms import HuggingFaceHub
+from sentence_transformers import SentenceTransformer
+import torch
+import re
+import hashlib
+import json
+import datetime
+
+
+class DocumentProcessor:
+    """
+    Classe per l'elaborazione e l'estrazione di testo da vari formati di documenti.
+    """
+    
+    def __init__(self, upload_dir):
+        """
+        Inizializza il processore di documenti.
+        
+        Args:
+            upload_dir (str): Directory dove salvare i documenti caricati
+        """
+        self.upload_dir = upload_dir
+        os.makedirs(upload_dir, exist_ok=True)
+    
+    def save_uploaded_file(self, file_obj, filename=None):
+        """
+        Salva un file caricato nella directory di upload.
+        
+        Args:
+            file_obj: Oggetto file caricato
+            filename (str, optional): Nome del file
+            
+        Returns:
+            str: Percorso del file salvato
+        """
+        if filename is None:
+            filename = file_obj.name
+        
+        # Genera un nome file sicuro
+        safe_filename = self._sanitize_filename(filename)
+        
+        # Aggiungi timestamp per evitare sovrascritture
+        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+        filename_with_timestamp = f"{timestamp}_{safe_filename}"
+        
+        # Percorso completo del file
+        file_path = os.path.join(self.upload_dir, filename_with_timestamp)
+        
+        # Salva il file
+        with open(file_path, 'wb') as f:
+            f.write(file_obj.read())
+        
+        return file_path
+    
+    def _sanitize_filename(self, filename):
+        """
+        Sanitizza un nome file rimuovendo caratteri non sicuri.
+        
+        Args:
+            filename (str): Nome file originale
+            
+        Returns:
+            str: Nome file sanitizzato
+        """
+        # Rimuovi caratteri non sicuri
+        safe_filename = re.sub(r'[^\w\.-]', '_', filename)
+        return safe_filename
+    
+    def extract_text(self, file_path):
+        """
+        Estrae il testo da un file in base al suo formato.
+        
+        Args:
+            file_path (str): Percorso del file
+            
+        Returns:
+            str: Testo estratto
+        """
+        # Determina il formato del file dall'estensione
+        _, ext = os.path.splitext(file_path)
+        ext = ext.lower()
+        
+        if ext == '.pdf':
+            return self.extract_text_from_pdf(file_path)
+        elif ext == '.docx':
+            return self.extract_text_from_docx(file_path)
+        elif ext == '.pptx':
+            return self.extract_text_from_pptx(file_path)
+        elif ext == '.txt':
+            return self.extract_text_from_txt(file_path)
+        else:
+            raise ValueError(f"Formato file non supportato: {ext}")
+    
+    def extract_text_from_pdf(self, pdf_path):
+        """
+        Estrae il testo da un file PDF.
+        
+        Args:
+            pdf_path (str): Percorso del file PDF
+            
+        Returns:
+            str: Testo estratto
+        """
+        text = ""
+        try:
+            # Apri il documento PDF
+            doc = fitz.open(pdf_path)
+            
+            # Estrai il testo da ogni pagina
+            for page_num in range(len(doc)):
+                page = doc.load_page(page_num)
+                text += page.get_text()
+            
+            # Chiudi il documento
+            doc.close()
+        except Exception as e:
+            print(f"Errore nell'estrazione del testo dal PDF {pdf_path}: {e}")
+        
+        return text
+    
+    def extract_text_from_docx(self, docx_path):
+        """
+        Estrae il testo da un file DOCX.
+        
+        Args:
+            docx_path (str): Percorso del file DOCX
+            
+        Returns:
+            str: Testo estratto
+        """
+        text = ""
+        try:
+            # Apri il documento DOCX
+            doc = docx.Document(docx_path)
+            
+            # Estrai il testo da ogni paragrafo
+            for para in doc.paragraphs:
+                text += para.text + "\n"
+            
+            # Estrai il testo dalle tabelle
+            for table in doc.tables:
+                for row in table.rows:
+                    for cell in row.cells:
+                        text += cell.text + " "
+                    text += "\n"
+        except Exception as e:
+            print(f"Errore nell'estrazione del testo dal DOCX {docx_path}: {e}")
+        
+        return text
+    
+    def extract_text_from_pptx(self, pptx_path):
+        """
+        Estrae il testo da un file PPTX.
+        
+        Args:
+            pptx_path (str): Percorso del file PPTX
+            
+        Returns:
+            str: Testo estratto
+        """
+        text = ""
+        try:
+            # Apri la presentazione PPTX
+            prs = pptx.Presentation(pptx_path)
+            
+            # Estrai il testo da ogni diapositiva
+            for slide in prs.slides:
+                for shape in slide.shapes:
+                    if hasattr(shape, "text"):
+                        text += shape.text + "\n"
+        except Exception as e:
+            print(f"Errore nell'estrazione del testo dal PPTX {pptx_path}: {e}")
+        
+        return text
+    
+    def extract_text_from_txt(self, txt_path):
+        """
+        Estrae il testo da un file TXT.
+        
+        Args:
+            txt_path (str): Percorso del file TXT
+            
+        Returns:
+            str: Testo estratto
+        """
+        try:
+            # Apri il file TXT
+            with open(txt_path, 'r', encoding='utf-8') as f:
+                text = f.read()
+        except UnicodeDecodeError:
+            # Prova con una codifica diversa
+            try:
+                with open(txt_path, 'r', encoding='latin-1') as f:
+                    text = f.read()
+            except Exception as e:
+                print(f"Errore nell'estrazione del testo dal TXT {txt_path}: {e}")
+                text = ""
+        except Exception as e:
+            print(f"Errore nell'estrazione del testo dal TXT {txt_path}: {e}")
+            text = ""
+        
+        return text
+    
+    def chunk_text(self, text, chunk_size=500, chunk_overlap=50):
+        """
+        Divide il testo in chunk più piccoli.
+        
+        Args:
+            text (str): Testo da dividere
+            chunk_size (int): Dimensione di ogni chunk in token
+            chunk_overlap (int): Sovrapposizione tra chunk consecutivi
+            
+        Returns:
+            list: Lista di chunk di testo
+        """
+        # Utilizza il text splitter di LangChain
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=chunk_size,
+            chunk_overlap=chunk_overlap,
+            length_function=len
+        )
+        
+        # Dividi il testo in chunk
+        chunks = text_splitter.split_text(text)
+        
+        return chunks
+    
+    def process_document(self, file_path, chunk_size=500, chunk_overlap=50):
+        """
+        Elabora un documento: estrae il testo e lo divide in chunk.
+        
+        Args:
+            file_path (str): Percorso del file
+            chunk_size (int): Dimensione di ogni chunk in token
+            chunk_overlap (int): Sovrapposizione tra chunk consecutivi
+            
+        Returns:
+            dict: Informazioni sul documento elaborato
+        """
+        # Estrai il testo dal documento
+        text = self.extract_text(file_path)
+        
+        # Dividi il testo in chunk
+        chunks = self.chunk_text(text, chunk_size, chunk_overlap)
+        
+        # Calcola l'hash del file per l'identificazione
+        file_hash = self._calculate_file_hash(file_path)
+        
+        # Ottieni il nome del file
+        filename = os.path.basename(file_path)
+        
+        # Crea metadati per il documento
+        metadata = {
+            'filename': filename,
+            'file_path': file_path,
+            'file_hash': file_hash,
+            'chunk_count': len(chunks),
+            'total_text_length': len(text),
+            'processing_date': datetime.datetime.now().isoformat()
+        }
+        
+        return {
+            'text': text,
+            'chunks': chunks,
+            'metadata': metadata
+        }
+    
+    def _calculate_file_hash(self, file_path):
+        """
+        Calcola l'hash SHA-256 di un file.
+        
+        Args:
+            file_path (str): Percorso del file
+            
+        Returns:
+            str: Hash SHA-256 del file
+        """
+        sha256_hash = hashlib.sha256()
+        
+        with open(file_path, "rb") as f:
+            # Leggi il file a blocchi per gestire file di grandi dimensioni
+            for byte_block in iter(lambda: f.read(4096), b""):
+                sha256_hash.update(byte_block)
+        
+        return sha256_hash.hexdigest()
+
+
+class VectorStore:
+    """
+    Classe per la gestione del vector store per il sistema RAG.
+    """
+    
+    def __init__(self, persist_directory, embedding_model_name="all-MiniLM-L6-v2"):
+        """
+        Inizializza il vector store.
+        
+        Args:
+            persist_directory (str): Directory dove salvare il vector store
+            embedding_model_name (str): Nome del modello di embedding
+        """
+        self.persist_directory = persist_directory
+        self.embedding_model_name = embedding_model_name
+        
+        # Crea la directory se non esiste
+        os.makedirs(persist_directory, exist_ok=True)
+        
+        # Inizializza il modello di embedding
+        self.embedding_model = self._initialize_embedding_model(embedding_model_name)
+        
+        # Inizializza il vector store
+        self.vector_store = self._initialize_vector_store()
+    
+    def _initialize_embedding_model(self, model_name):
+        """
+        Inizializza il modello di embedding.
+        
+        Args:
+            model_name (str): Nome del modello
+            
+        Returns:
+            object: Modello di embedding
+        """
+        try:
+            # Utilizza HuggingFaceEmbeddings di LangChain
+            embedding_model = HuggingFaceEmbeddings(model_name=model_name)
+            return embedding_model
+        except Exception as e:
+            print(f"Errore nell'inizializzazione del modello di embedding: {e}")
+            # Fallback: carica direttamente il modello con sentence-transformers
+            return SentenceTransformer(model_name)
+    
+    def _initialize_vector_store(self):
+        """
+        Inizializza il vector store.
+        
+        Returns:
+            object: Vector store
+        """
+        try:
+            # Controlla se esiste già un vector store
+            if os.path.exists(os.path.join(self.persist_directory, 'chroma.sqlite3')):
+                # Carica il vector store esistente
+                vector_store = Chroma(
+                    persist_directory=self.persist_directory,
+                    embedding_function=self.embedding_model
+                )
+            else:
+                # Crea un nuovo vector store
+                vector_store = Chroma(
+                    persist_directory=self.persist_directory,
+                    embedding_function=self.embedding_model
+                )
+            
+            return vector_store
+        except Exception as e:
+            print(f"Errore nell'inizializzazione del vector store: {e}")
+            # Fallback: utilizza direttamente ChromaDB
+            client = chromadb.PersistentClient(path=self.persist_directory)
+            collection_name = "forensic_graphology_docs"
+            
+            # Controlla se la collezione esiste già
+            try:
+                collection = client.get_collection(name=collection_name)
+            except:
+                # Crea una nuova collezione
+                collection = client.create_collection(name=collection_name)
+            
+            return collection
+    
+    def add_document(self, document_info):
+        """
+        Aggiunge un documento al vector store.
+        
+        Args:
+            document_info (dict): Informazioni sul documento
+            
+        Returns:
+            dict: Risultato dell'operazione
+        """
+        chunks = document_info['chunks']
+        metadata = document_info['metadata']
+        
+        # Crea documenti LangChain
+        documents = []
+        for i, chunk in enumerate(chunks):
+            # Crea metadati per il chunk
+            chunk_metadata = metadata.copy()
+            chunk_metadata['chunk_id'] = i
+            chunk_metadata['chunk_index'] = i
+            chunk_metadata['chunk_total'] = len(chunks)
+            
+            # Crea un documento LangChain
+            doc = Document(page_content=chunk, metadata=chunk_metadata)
+            documents.append(doc)
+        
+        try:
+            # Aggiungi i documenti al vector store
+            self.vector_store.add_documents(documents)
+            
+            return {
+                'success': True,
+                'document_id': metadata['file_hash'],
+                'chunks_added': len(chunks)
+            }
+        except Exception as e:
+            print(f"Errore nell'aggiunta del documento al vector store: {e}")
+            return {
+                'success': False,
+                'error': str(e)
+            }
+    
+    def search(self, query, k=4):
+        """
+        Cerca documenti simili alla query.
+        
+        Args:
+            query (str): Query di ricerca
+            k (int): Numero di risultati da restituire
+            
+        Returns:
+            list: Lista di documenti simili
+        """
+        try:
+            # Cerca documenti simili
+            results = self.vector_store.similarity_search(query, k=k)
+            return results
+        except Exception as e:
+            print(f"Errore nella ricerca: {e}")
+            return []
+    
+    def delete_document(self, document_id):
+        """
+        Elimina un documento dal vector store.
+        
+        Args:
+            document_id (str): ID del documento
+            
+        Returns:
+            dict: Risultato dell'operazione
+        """
+        try:
+            # Elimina il documento
+            self.vector_store.delete(filter={"file_hash": document_id})
+            
+            return {
+                'success': True,
+                'document_id': document_id
+            }
+        except Exception as e:
+            print(f"Errore nell'eliminazione del documento: {e}")
+            return {
+                'success': False,
+                'error': str(e)
+            }
+    
+    def get_all_documents(self):
+        """
+        Ottiene tutti i documenti nel vector store.
+        
+        Returns:
+            list: Lista di documenti
+        """
+        try:
+            # Ottieni tutti i documenti
+            results = self.vector_store.get()
+            
+            # Estrai i metadati unici
+            unique_docs = {}
+            for i, metadata in enumerate(results['metadatas']):
+                if 'file_hash' in metadata:
+                    file_hash = metadata['file_hash']
+                    if file_hash not in unique_docs:
+                        unique_docs[file_hash] = {
+                            'document_id': file_hash,
+                            'filename': metadata.get('filename', 'Unknown'),
+                            'file_path': metadata.get('file_path', ''),
+                            'chunk_total': metadata.get('chunk_total', 0),
+                            'processing_date': metadata.get('processing_date', '')
+                        }
+            
+            return list(unique_docs.values())
+        except Exception as e:
+            print(f"Errore nel recupero dei documenti: {e}")
+            return []
+
+
+class RAGSystem:
+    """
+    Classe per il sistema RAG (Retrieval Augmented Generation).
+    """
+    
+    def __init__(self, upload_dir, vector_store_dir, use_local_model=False, model_name=None):
+        """
+        Inizializza il sistema RAG.
+        
+        Args:
+            upload_dir (str): Directory per i documenti caricati
+            vector_store_dir (str): Directory per il vector store
+            use_local_model (bool): Se utilizzare un modello locale
+            model_name (str): Nome del modello da utilizzare
+        """
+        self.document_processor = DocumentProcessor(upload_dir)
+        self.vector_store = VectorStore(vector_store_dir)
+        self.use_local_model = use_local_model
+        self.model_name = model_name
+        
+        # Inizializza il modello come None (modalità senza LLM)
+        self.model = None
+        
+        # Prova a inizializzare il modello solo se specificato
+        if model_name:
+            try:
+                self._initialize_model(use_local_model, model_name)
+            except Exception as e:
+                print(f"Errore nell'inizializzazione del modello: {e}")
+                print("Il sistema RAG funzionerà in modalità di sola ricerca (senza generazione).")
+    
+    def _initialize_model(self, use_local_model, model_name):
+        """
+        Inizializza il modello di linguaggio.
+        
+        Args:
+            use_local_model (bool): Se utilizzare un modello locale
+            model_name (str): Nome del modello
+            
+        Returns:
+            object: Modello di linguaggio
+        """
+        # In questa versione semplificata, non inizializziamo alcun modello
+        # per evitare problemi di dipendenze e token API
+        print("Modalità di sola ricerca attivata (senza generazione).")
+        return None
+    
+    def process_and_store_document(self, file_obj, filename=None):
+        """
+        Elabora e memorizza un documento.
+        
+        Args:
+            file_obj: Oggetto file caricato
+            filename (str, optional): Nome del file
+            
+        Returns:
+            dict: Risultato dell'operazione
+        """
+        try:
+            # Salva il file caricato
+            file_path = self.document_processor.save_uploaded_file(file_obj, filename)
+            
+            # Elabora il documento
+            document_info = self.document_processor.process_document(file_path)
+            
+            # Aggiungi il documento al vector store
+            result = self.vector_store.add_document(document_info)
+            
+            # Aggiungi informazioni aggiuntive al risultato
+            result['filename'] = os.path.basename(file_path)
+            result['file_path'] = file_path
+            result['chunk_count'] = len(document_info['chunks'])
+            
+            return result
+        except Exception as e:
+            print(f"Errore nell'elaborazione e memorizzazione del documento: {e}")
+            return {
+                'success': False,
+                'error': str(e)
+            }
+    
+    def query(self, query_text, k=4, scrub_sensitive=True):
+        """
+        Esegue una query sul sistema RAG.
+        
+        Args:
+            query_text (str): Testo della query
+            k (int): Numero di documenti da recuperare
+            scrub_sensitive (bool): Se rimuovere informazioni sensibili
+            
+        Returns:
+            dict: Risultato della query
+        """
+        try:
+            # Cerca documenti simili
+            retrieved_docs = self.vector_store.search(query_text, k=k)
+            
+            # Estrai il contesto dai documenti
+            context = self._build_context(retrieved_docs, scrub_sensitive)
+            
+            # Prepara i riferimenti
+            references = self._prepare_references(retrieved_docs)
+            
+            # Se non c'è un modello, restituisci solo i documenti recuperati
+            if self.model is None:
+                response = "Modalità di sola ricerca attiva. Ecco i documenti più rilevanti per la tua query:\n\n"
+                for i, doc in enumerate(retrieved_docs):
+                    response += f"[Documento {i+1}] {doc.metadata.get('filename', 'Unknown')}\n"
+                    response += f"Estratto: {doc.page_content[:200]}...\n\n"
+            else:
+                # Crea il prompt
+                prompt = self._create_prompt(query_text, context)
+                
+                # Genera la risposta
+                response = self._generate_response(prompt)
+            
+            return {
+                'success': True,
+                'query': query_text,
+                'response': response,
+                'references': references
+            }
+        except Exception as e:
+            print(f"Errore nell'esecuzione della query: {e}")
+            return {
+                'success': False,
+                'error': str(e),
+                'query': query_text
+            }
+    
+    def _build_context(self, documents, scrub_sensitive=True):
+        """
+        Costruisce il contesto dai documenti recuperati.
+        
+        Args:
+            documents (list): Lista di documenti
+            scrub_sensitive (bool): Se rimuovere informazioni sensibili
+            
+        Returns:
+            str: Contesto
+        """
+        context_parts = []
+        
+        for i, doc in enumerate(documents):
+            # Estrai il contenuto e i metadati
+            content = doc.page_content
+            metadata = doc.metadata
+            
+            # Rimuovi informazioni sensibili se richiesto
+            if scrub_sensitive:
+                content = self._scrub_sensitive_info(content)
+            
+            # Aggiungi il contenuto al contesto
+            context_parts.append(f"[Documento {i+1}] {content}")
+        
+        # Unisci le parti del contesto
+        context = "\n\n".join(context_parts)
+        
+        return context
+    
+    def _scrub_sensitive_info(self, text):
+        """
+        Rimuove informazioni sensibili dal testo.
+        
+        Args:
+            text (str): Testo da elaborare
+            
+        Returns:
+            str: Testo elaborato
+        """
+        # Rimuovi numeri di telefono
+        text = re.sub(r'\b\d{10}\b', '[TELEFONO]', text)
+        text = re.sub(r'\b\d{3}[-.\s]?\d{3}[-.\s]?\d{4}\b', '[TELEFONO]', text)
+        
+        # Rimuovi indirizzi email
+        text = re.sub(r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b', '[EMAIL]', text)
+        
+        # Rimuovi codici fiscali italiani
+        text = re.sub(r'\b[A-Z]{6}\d{2}[A-Z]\d{2}[A-Z]\d{3}[A-Z]\b', '[CODICE_FISCALE]', text)
+        
+        # Rimuovi numeri di carte di credito
+        text = re.sub(r'\b\d{4}[-\s]?\d{4}[-\s]?\d{4}[-\s]?\d{4}\b', '[CARTA_DI_CREDITO]', text)
+        
+        # Rimuovi IBAN
+        text = re.sub(r'\b[A-Z]{2}\d{2}[A-Z0-9]{4}\d{7}[A-Z0-9]{0,16}\b', '[IBAN]', text)
+        
+        return text
+    
+    def _create_prompt(self, query, context):
+        """
+        Crea il prompt per il modello.
+        
+        Args:
+            query (str): Query dell'utente
+            context (str): Contesto dai documenti
+            
+        Returns:
+            str: Prompt
+        """
+        prompt_template = """
+        Sei un consulente di Grafologia Forense. Ti fornisco del contesto da documenti caricati.
+        Rispondi in modo coerente e professionale, senza rivelare mai dati privati.
+        
+        CONTENUTO RILEVANTE:
+        {context}
+        
+        DOMANDA: {query}
+        
+        RISPOSTA:
+        """
+        
+        # Crea il prompt
+        prompt = PromptTemplate(
+            template=prompt_template,
+            input_variables=["context", "query"]
+        )
+        
+        # Formatta il prompt
+        formatted_prompt = prompt.format(context=context, query=query)
+        
+        return formatted_prompt
+    
+    def _generate_response(self, prompt):
+        """
+        Genera una risposta dal modello.
+        
+        Args:
+            prompt (str): Prompt per il modello
+            
+        Returns:
+            str: Risposta generata
+        """
+        if self.model is None:
+            return "Mi dispiace, il modello di linguaggio non è disponibile al momento."
+        
+        try:
+            # Crea una chain
+            chain = LLMChain(llm=self.model, prompt=PromptTemplate.from_template(prompt))
+            
+            # Genera la risposta
+            response = chain.run("")
+            
+            return response
+        except Exception as e:
+            print(f"Errore nella generazione della risposta: {e}")
+            
+            # Fallback: risposta semplice
+            return "Mi dispiace, non sono riuscito a generare una risposta. Si è verificato un errore."
+    
+    def _prepare_references(self, documents):
+        """
+        Prepara i riferimenti ai documenti.
+        
+        Args:
+            documents (list): Lista di documenti
+            
+        Returns:
+            list: Lista di riferimenti
+        """
+        references = []
+        
+        for i, doc in enumerate(documents):
+            # Estrai i metadati
+            metadata = doc.metadata
+            
+            # Crea un riferimento
+            reference = {
+                'id': i + 1,
+                'filename': metadata.get('filename', 'Unknown'),
+                'chunk_id': metadata.get('chunk_id', 0),
+                'chunk_index': metadata.get('chunk_index', 0),
+                'chunk_total': metadata.get('chunk_total', 0),
+                'snippet': doc.page_content[:100] + "..." if len(doc.page_content) > 100 else doc.page_content
+            }
+            
+            references.append(reference)
+        
+        return references
+    
+    def get_document_list(self):
+        """
+        Ottiene la lista dei documenti memorizzati.
+        
+        Returns:
+            list: Lista di documenti
+        """
+        return self.vector_store.get_all_documents()
+    
+    def delete_document(self, document_id):
+        """
+        Elimina un documento.
+        
+        Args:
+            document_id (str): ID del documento
+            
+        Returns:
+            dict: Risultato dell'operazione
+        """
+        return self.vector_store.delete_document(document_id)

src/signature_analysis.py

@@ -0,0 +1,412 @@
+import cv2
+import numpy as np
+from sklearn.metrics.pairwise import cosine_similarity
+import matplotlib.pyplot as plt
+from .preprocessing import ImagePreprocessor
+
+class SignatureAnalyzer:
+    """
+    Classe per l'analisi e la comparazione di firme.
+    Implementa funzionalità per estrarre caratteristiche dalle firme,
+    confrontarle e calcolare metriche di similarità.
+    """
+    
+    def __init__(self):
+        """Inizializza l'analizzatore di firme."""
+        self.preprocessor = ImagePreprocessor()
+    
+    def extract_contours(self, binary_image):
+        """
+        Estrae i contorni da un'immagine binaria.
+        
+        Args:
+            binary_image (numpy.ndarray): Immagine binaria
+            
+        Returns:
+            list: Lista di contorni
+        """
+        contours, _ = cv2.findContours(binary_image, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        return contours
+    
+    def extract_features_orb(self, image, n_features=1000):
+        """
+        Estrae caratteristiche ORB (Oriented FAST and Rotated BRIEF) da un'immagine.
+        
+        Args:
+            image (numpy.ndarray): Immagine di input
+            n_features (int): Numero di caratteristiche da estrarre
+            
+        Returns:
+            tuple: (keypoints, descriptors)
+        """
+        # Converti in scala di grigi se necessario
+        if len(image.shape) > 2:
+            gray = self.preprocessor.convert_to_grayscale(image)
+        else:
+            gray = image
+        
+        # Inizializza il rilevatore ORB
+        orb = cv2.ORB_create(nfeatures=n_features)
+        
+        # Rileva keypoints e calcola i descrittori
+        keypoints, descriptors = orb.detectAndCompute(gray, None)
+        
+        return keypoints, descriptors
+    
+    def match_features(self, desc1, desc2, method='bf'):
+        """
+        Confronta i descrittori di due immagini.
+        
+        Args:
+            desc1 (numpy.ndarray): Descrittori della prima immagine
+            desc2 (numpy.ndarray): Descrittori della seconda immagine
+            method (str): Metodo di matching ('bf' per Brute Force, 'flann' per FLANN)
+            
+        Returns:
+            list: Lista di corrispondenze
+        """
+        if desc1 is None or desc2 is None:
+            return []
+        
+        if method == 'bf':
+            # Brute Force Matcher con norma di Hamming (per descrittori binari come ORB)
+            matcher = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
+            matches = matcher.match(desc1, desc2)
+            
+            # Ordina le corrispondenze in base alla distanza
+            matches = sorted(matches, key=lambda x: x.distance)
+            
+        elif method == 'flann':
+            # FLANN Matcher (più veloce per dataset di grandi dimensioni)
+            # Converti i descrittori in float32 se necessario
+            if desc1.dtype != np.float32:
+                desc1 = np.float32(desc1)
+            if desc2.dtype != np.float32:
+                desc2 = np.float32(desc2)
+                
+            FLANN_INDEX_LSH = 6
+            index_params = dict(algorithm=FLANN_INDEX_LSH,
+                               table_number=6,
+                               key_size=12,
+                               multi_probe_level=1)
+            search_params = dict(checks=50)
+            
+            flann = cv2.FlannBasedMatcher(index_params, search_params)
+            matches = flann.knnMatch(desc1, desc2, k=2)
+            
+            # Applica il test del rapporto di Lowe
+            good_matches = []
+            for pair in matches:
+                if len(pair) == 2:
+                    m, n = pair
+                    if m.distance < 0.7 * n.distance:
+                        good_matches.append(m)
+            matches = good_matches
+        else:
+            raise ValueError(f"Metodo di matching non supportato: {method}")
+        
+        return matches
+    
+    def calculate_similarity_score(self, matches, kp1, kp2):
+        """
+        Calcola un punteggio di similarità basato sulle corrispondenze.
+        
+        Args:
+            matches (list): Lista di corrispondenze
+            kp1 (list): Keypoints della prima immagine
+            kp2 (list): Keypoints della seconda immagine
+            
+        Returns:
+            float: Punteggio di similarità (0-100)
+        """
+        if len(matches) == 0 or len(kp1) == 0 or len(kp2) == 0:
+            return 0.0
+        
+        # Calcola il punteggio come rapporto tra il numero di corrispondenze e il minimo numero di keypoints
+        score = 100.0 * len(matches) / min(len(kp1), len(kp2))
+        
+        return min(score, 100.0)  # Limita il punteggio a 100
+    
+    def extract_signature_metrics(self, binary_image):
+        """
+        Estrae metriche grafometriche da una firma.
+        
+        Args:
+            binary_image (numpy.ndarray): Immagine binaria della firma
+            
+        Returns:
+            dict: Dizionario di metriche
+        """
+        # Estrai i contorni
+        contours = self.extract_contours(binary_image)
+        
+        if not contours:
+            return {
+                'area': 0,
+                'perimeter': 0,
+                'width': 0,
+                'height': 0,
+                'aspect_ratio': 0,
+                'density': 0,
+                'slant_angle': 0
+            }
+        
+        # Trova il contorno più grande (la firma)
+        signature_contour = max(contours, key=cv2.contourArea)
+        
+        # Calcola l'area
+        area = cv2.contourArea(signature_contour)
+        
+        # Calcola il perimetro
+        perimeter = cv2.arcLength(signature_contour, True)
+        
+        # Calcola il rettangolo delimitatore
+        x, y, w, h = cv2.boundingRect(signature_contour)
+        
+        # Calcola il rapporto d'aspetto
+        aspect_ratio = float(w) / h if h > 0 else 0
+        
+        # Calcola la densità (area / area del rettangolo delimitatore)
+        density = area / (w * h) if w * h > 0 else 0
+        
+        # Calcola l'angolo di inclinazione
+        # Utilizziamo l'ellisse che meglio approssima il contorno
+        if len(signature_contour) >= 5:  # Servono almeno 5 punti per adattare un'ellisse
+            ellipse = cv2.fitEllipse(signature_contour)
+            # L'angolo è in gradi, 0-180
+            slant_angle = ellipse[2]
+            # Normalizziamo l'angolo a -90 - +90 gradi
+            if slant_angle > 90:
+                slant_angle = slant_angle - 180
+        else:
+            slant_angle = 0
+        
+        return {
+            'area': area,
+            'perimeter': perimeter,
+            'width': w,
+            'height': h,
+            'aspect_ratio': aspect_ratio,
+            'density': density,
+            'slant_angle': slant_angle
+        }
+    
+    def compare_signatures(self, image_path1, image_path2):
+        """
+        Confronta due firme e calcola metriche di similarità.
+        
+        Args:
+            image_path1 (str): Percorso della prima immagine
+            image_path2 (str): Percorso della seconda immagine
+            
+        Returns:
+            dict: Risultati del confronto
+        """
+        # Pre-elabora le firme
+        sig1_processed = self.preprocessor.preprocess_signature(image_path1)
+        sig2_processed = self.preprocessor.preprocess_signature(image_path2)
+        
+        # Estrai caratteristiche ORB
+        kp1, desc1 = self.extract_features_orb(sig1_processed['binary'])
+        kp2, desc2 = self.extract_features_orb(sig2_processed['binary'])
+        
+        # Trova le corrispondenze
+        matches = self.match_features(desc1, desc2, method='bf')
+        
+        # Calcola il punteggio di similarità
+        similarity_score = self.calculate_similarity_score(matches, kp1, kp2)
+        
+        # Estrai metriche grafometriche
+        metrics1 = self.extract_signature_metrics(sig1_processed['binary'])
+        metrics2 = self.extract_signature_metrics(sig2_processed['binary'])
+        
+        # Calcola le differenze tra le metriche
+        metric_diffs = {
+            'area_diff': abs(metrics1['area'] - metrics2['area']) / max(metrics1['area'], metrics2['area'], 1) * 100,
+            'perimeter_diff': abs(metrics1['perimeter'] - metrics2['perimeter']) / max(metrics1['perimeter'], metrics2['perimeter'], 1) * 100,
+            'aspect_ratio_diff': abs(metrics1['aspect_ratio'] - metrics2['aspect_ratio']) / max(metrics1['aspect_ratio'], metrics2['aspect_ratio'], 1) * 100,
+            'density_diff': abs(metrics1['density'] - metrics2['density']) / max(metrics1['density'], metrics2['density'], 1) * 100,
+            'slant_angle_diff': abs(metrics1['slant_angle'] - metrics2['slant_angle'])
+        }
+        
+        # Calcola un punteggio di similarità basato sulle metriche
+        # Minore è la differenza, maggiore è la similarità
+        metric_similarity = 100 - (
+            0.2 * metric_diffs['area_diff'] +
+            0.2 * metric_diffs['perimeter_diff'] +
+            0.2 * metric_diffs['aspect_ratio_diff'] +
+            0.2 * metric_diffs['density_diff'] +
+            0.2 * min(metric_diffs['slant_angle_diff'] / 90 * 100, 100)  # Normalizza la differenza di angolo
+        )
+        
+        # Combina i punteggi (50% feature matching, 50% metriche)
+        combined_score = 0.5 * similarity_score + 0.5 * metric_similarity
+        
+        return {
+            'feature_similarity': similarity_score,
+            'metric_similarity': metric_similarity,
+            'combined_score': combined_score,
+            'metrics1': metrics1,
+            'metrics2': metrics2,
+            'metric_differences': metric_diffs,
+            'keypoints1': len(kp1),
+            'keypoints2': len(kp2),
+            'matches': len(matches),
+            'processed_images': {
+                'signature1': sig1_processed,
+                'signature2': sig2_processed
+            }
+        }
+    
+    def visualize_comparison(self, comparison_result, save_path=None):
+        """
+        Visualizza il confronto tra due firme.
+        
+        Args:
+            comparison_result (dict): Risultato del confronto
+            save_path (str, optional): Percorso dove salvare l'immagine
+            
+        Returns:
+            matplotlib.figure.Figure: Figura con la visualizzazione
+        """
+        # Crea una figura con più sottografici
+        fig, axs = plt.subplots(2, 3, figsize=(15, 10))
+        
+        # Immagini originali
+        axs[0, 0].imshow(cv2.cvtColor(comparison_result['processed_images']['signature1']['original'], cv2.COLOR_BGR2RGB))
+        axs[0, 0].set_title('Firma 1 (Originale)')
+        axs[0, 0].axis('off')
+        
+        axs[0, 1].imshow(cv2.cvtColor(comparison_result['processed_images']['signature2']['original'], cv2.COLOR_BGR2RGB))
+        axs[0, 1].set_title('Firma 2 (Originale)')
+        axs[0, 1].axis('off')
+        
+        # Immagini binarie
+        axs[0, 2].imshow(comparison_result['processed_images']['signature1']['binary'], cmap='gray')
+        axs[0, 2].set_title('Firma 1 (Binaria)')
+        axs[0, 2].axis('off')
+        
+        axs[1, 0].imshow(comparison_result['processed_images']['signature2']['binary'], cmap='gray')
+        axs[1, 0].set_title('Firma 2 (Binaria)')
+        axs[1, 0].axis('off')
+        
+        # Grafico a barre per i punteggi di similarità
+        scores = ['Feature Similarity', 'Metric Similarity', 'Combined Score']
+        values = [comparison_result['feature_similarity'], 
+                 comparison_result['metric_similarity'], 
+                 comparison_result['combined_score']]
+        
+        axs[1, 1].bar(scores, values, color=['blue', 'green', 'red'])
+        axs[1, 1].set_ylim(0, 100)
+        axs[1, 1].set_ylabel('Punteggio (%)')
+        axs[1, 1].set_title('Punteggi di Similarità')
+        
+        # Tabella con le metriche
+        metrics_table = [
+            ['Metrica', 'Firma 1', 'Firma 2', 'Diff (%)'],
+            ['Area', f"{comparison_result['metrics1']['area']:.1f}", f"{comparison_result['metrics2']['area']:.1f}", 
+             f"{comparison_result['metric_differences']['area_diff']:.1f}"],
+            ['Perimetro', f"{comparison_result['metrics1']['perimeter']:.1f}", f"{comparison_result['metrics2']['perimeter']:.1f}", 
+             f"{comparison_result['metric_differences']['perimeter_diff']:.1f}"],
+            ['Rapporto Aspetto', f"{comparison_result['metrics1']['aspect_ratio']:.2f}", f"{comparison_result['metrics2']['aspect_ratio']:.2f}", 
+             f"{comparison_result['metric_differences']['aspect_ratio_diff']:.1f}"],
+            ['Densità', f"{comparison_result['metrics1']['density']:.2f}", f"{comparison_result['metrics2']['density']:.2f}", 
+             f"{comparison_result['metric_differences']['density_diff']:.1f}"],
+            ['Inclinazione (°)', f"{comparison_result['metrics1']['slant_angle']:.1f}", f"{comparison_result['metrics2']['slant_angle']:.1f}", 
+             f"{comparison_result['metric_differences']['slant_angle_diff']:.1f}"]
+        ]
+        
+        axs[1, 2].axis('tight')
+        axs[1, 2].axis('off')
+        table = axs[1, 2].table(cellText=metrics_table, loc='center', cellLoc='center')
+        table.auto_set_font_size(False)
+        table.set_fontsize(9)
+        table.scale(1, 1.5)
+        
+        # Aggiungi un titolo generale
+        plt.suptitle(f"Analisi Comparativa delle Firme - Score: {comparison_result['combined_score']:.1f}%", 
+                    fontsize=16)
+        
+        plt.tight_layout(rect=[0, 0, 1, 0.95])
+        
+        # Salva l'immagine se richiesto
+        if save_path:
+            plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        
+        return fig
+    
+    def generate_comparison_report(self, comparison_result):
+        """
+        Genera un report testuale del confronto tra firme.
+        
+        Args:
+            comparison_result (dict): Risultato del confronto
+            
+        Returns:
+            str: Report testuale
+        """
+        report = []
+        report.append("REPORT DI ANALISI COMPARATIVA DELLE FIRME")
+        report.append("=" * 50)
+        report.append("")
+        
+        # Punteggi di similarità
+        report.append("PUNTEGGI DI SIMILARITÀ:")
+        report.append(f"- Similarità delle caratteristiche: {comparison_result['feature_similarity']:.2f}%")
+        report.append(f"- Similarità delle metriche: {comparison_result['metric_similarity']:.2f}%")
+        report.append(f"- Punteggio combinato: {comparison_result['combined_score']:.2f}%")
+        report.append("")
+        
+        # Interpretazione del punteggio
+        if comparison_result['combined_score'] >= 85:
+            interpretation = "ALTA probabilità che le firme provengano dalla stessa persona."
+        elif comparison_result['combined_score'] >= 70:
+            interpretation = "MEDIA-ALTA probabilità che le firme provengano dalla stessa persona."
+        elif comparison_result['combined_score'] >= 50:
+            interpretation = "MEDIA probabilità che le firme provengano dalla stessa persona."
+        elif comparison_result['combined_score'] >= 30:
+            interpretation = "BASSA probabilità che le firme provengano dalla stessa persona."
+        else:
+            interpretation = "MOLTO BASSA probabilità che le firme provengano dalla stessa persona."
+        
+        report.append(f"INTERPRETAZIONE: {interpretation}")
+        report.append("")
+        
+        # Dettagli tecnici
+        report.append("DETTAGLI TECNICI:")
+        report.append(f"- Punti chiave rilevati nella Firma 1: {comparison_result['keypoints1']}")
+        report.append(f"- Punti chiave rilevati nella Firma 2: {comparison_result['keypoints2']}")
+        report.append(f"- Corrispondenze trovate: {comparison_result['matches']}")
+        report.append("")
+        
+        # Metriche grafometriche
+        report.append("METRICHE GRAFOMETRICHE:")
+        report.append(f"{'Metrica':<20} {'Firma 1':<15} {'Firma 2':<15} {'Differenza (%)':<15}")
+        report.append("-" * 65)
+        
+        metrics = [
+            ('Area', comparison_result['metrics1']['area'], comparison_result['metrics2']['area'], 
+             comparison_result['metric_differences']['area_diff']),
+            ('Perimetro', comparison_result['metrics1']['perimeter'], comparison_result['metrics2']['perimeter'], 
+             comparison_result['metric_differences']['perimeter_diff']),
+            ('Larghezza', comparison_result['metrics1']['width'], comparison_result['metrics2']['width'], 
+             abs(comparison_result['metrics1']['width'] - comparison_result['metrics2']['width']) / 
+             max(comparison_result['metrics1']['width'], comparison_result['metrics2']['width'], 1) * 100),
+            ('Altezza', comparison_result['metrics1']['height'], comparison_result['metrics2']['height'], 
+             abs(comparison_result['metrics1']['height'] - comparison_result['metrics2']['height']) / 
+             max(comparison_result['metrics1']['height'], comparison_result['metrics2']['height'], 1) * 100),
+            ('Rapporto Aspetto', comparison_result['metrics1']['aspect_ratio'], comparison_result['metrics2']['aspect_ratio'], 
+             comparison_result['metric_differences']['aspect_ratio_diff']),
+            ('Densità', comparison_result['metrics1']['density'], comparison_result['metrics2']['density'], 
+             comparison_result['metric_differences']['density_diff']),
+            ('Inclinazione (°)', comparison_result['metrics1']['slant_angle'], comparison_result['metrics2']['slant_angle'], 
+             comparison_result['metric_differences']['slant_angle_diff'])
+        ]
+        
+        for name, val1, val2, diff in metrics:
+            report.append(f"{name:<20} {val1:<15.2f} {val2:<15.2f} {diff:<15.2f}")
+        
+        report.append("")
+        report.append("NOTA: Questo report è generato automaticamente e deve essere interpretato da un esperto di grafologia forense.")
+        
+        return "\n".join(report)