classify_image.py

#!/usr/bin/env python3
"""
Script per classificare singole immagini usando il modello addestrato.

Questo script carica un modello pre-addestrato e classifica una singola immagine,
determinando se contiene un orologio o meno.
"""

import sys
import os
import numpy as np
# import cv2  # Non necessario per questo script
from tensorflow import keras
from PIL import Image
import matplotlib.pyplot as plt

# Configurazione
IMG_HEIGHT = 224
IMG_WIDTH = 224
MODEL_PATH = 'model/watch_classifier.h5'

def load_model():
    """
    Carica il modello addestrato.
    """
    if not os.path.exists(MODEL_PATH):
        raise FileNotFoundError(f"Modello non trovato in {MODEL_PATH}")
    
    print(f"Caricamento modello da {MODEL_PATH}...")
    model = keras.models.load_model(MODEL_PATH)
    return model

def preprocess_image(image_path):
    """
    Preprocessa l'immagine per la predizione.
    
    Args:
        image_path (str): Percorso dell'immagine da processare
    
    Returns:
        np.ndarray: Immagine preprocessata
        PIL.Image: Immagine originale per visualizzazione
    """
    # Carica l'immagine
    original_image = Image.open(image_path)
    
    # Converti in RGB se necessario
    if original_image.mode != 'RGB':
        original_image = original_image.convert('RGB')
    
    # Ridimensiona l'immagine
    image = original_image.resize((IMG_WIDTH, IMG_HEIGHT))
    
    # Converti in array numpy e normalizza
    image_array = np.array(image) / 255.0
    
    # Aggiungi dimensione batch
    image_array = np.expand_dims(image_array, axis=0)
    
    return image_array, original_image

def classify_image(model, image_path, show_image=True):
    """
    Classifica una singola immagine.
    
    Args:
        model: Modello Keras caricato
        image_path (str): Percorso dell'immagine
        show_image (bool): Se True, mostra l'immagine
    
    Returns:
        tuple: (prediction_probability, predicted_class, confidence)
    """
    # Preprocessa l'immagine
    processed_image, original_image = preprocess_image(image_path)
    
    # Fai la predizione
    prediction = model.predict(processed_image, verbose=0)[0][0]
    
    # Determina la classe e la confidenza
    if prediction > 0.5:
        predicted_class = "watch"
        confidence = prediction
    else:
        predicted_class = "no_watch"
        confidence = 1 - prediction
    
    # Mostra l'immagine se richiesto
    if show_image:
        plt.figure(figsize=(8, 6))
        plt.imshow(original_image)
        plt.axis('off')
        plt.title(f'Predizione: {predicted_class.upper()}\nConfidenza: {confidence:.2%}', 
                 fontsize=14, fontweight='bold')
        plt.tight_layout()
        plt.show()
    
    return prediction, predicted_class, confidence

def classify_multiple_images(model, image_paths):
    """
    Classifica multiple immagini.
    
    Args:
        model: Modello Keras caricato
        image_paths (list): Lista di percorsi delle immagini
    """
    results = []
    
    for image_path in image_paths:
        try:
            prediction, predicted_class, confidence = classify_image(
                model, image_path, show_image=False
            )
            results.append({
                'image_path': image_path,
                'prediction': predicted_class,
                'confidence': confidence,
                'raw_score': prediction
            })
        except Exception as e:
            print(f"Errore nel processare {image_path}: {e}")
            results.append({
                'image_path': image_path,
                'prediction': 'error',
                'confidence': 0.0,
                'raw_score': 0.0
            })
    
    return results

def print_results(image_path, prediction, predicted_class, confidence):
    """
    Stampa i risultati della classificazione in formato leggibile.
    """
    print("\n" + "="*50)
    print("RISULTATI CLASSIFICAZIONE")
    print("="*50)
    print(f"Immagine: {image_path}")
    print(f"Predizione: {predicted_class.upper()}")
    print(f"Confidenza: {confidence:.2%}")
    print(f"Score grezzo: {prediction:.4f}")
    print("="*50)
    
    # Interpretazione della confidenza
    if confidence >= 0.9:
        print("🟢 Predizione molto sicura")
    elif confidence >= 0.7:
        print("🟡 Predizione abbastanza sicura")
    elif confidence >= 0.6:
        print("🟠 Predizione incerta")
    else:
        print("🔴 Predizione molto incerta")

def main():
    """
    Funzione principale.
    """
    if len(sys.argv) < 2:
        print("Uso: python classify_image.py <percorso_immagine> [<altra_immagine>...]")
        print("\nEsempi:")
        print("  python classify_image.py sample_images/watch_example.jpg")
        print("  python classify_image.py image1.jpg image2.jpg image3.jpg")
        sys.exit(1)
    
    image_paths = sys.argv[1:]
    
    try:
        # Carica il modello
        model = load_model()
        print("Modello caricato con successo!")
        
        if len(image_paths) == 1:
            # Classifica una singola immagine
            image_path = image_paths[0]
            
            if not os.path.exists(image_path):
                print(f"Errore: File {image_path} non trovato!")
                sys.exit(1)
            
            print(f"\nClassificazione di: {image_path}")
            prediction, predicted_class, confidence = classify_image(model, image_path)
            print_results(image_path, prediction, predicted_class, confidence)
            
        else:
            # Classifica multiple immagini
            print(f"\nClassificazione di {len(image_paths)} immagini...")
            results = classify_multiple_images(model, image_paths)
            
            print("\n" + "="*80)
            print("RISULTATI CLASSIFICAZIONE MULTIPLA")
            print("="*80)
            
            for result in results:
                if result['prediction'] != 'error':
                    print(f"{result['image_path']:<40} | {result['prediction']:<10} | {result['confidence']:.2%}")
                else:
                    print(f"{result['image_path']:<40} | ERROR")
            
            print("="*80)
            
            # Statistiche
            valid_results = [r for r in results if r['prediction'] != 'error']
            if valid_results:
                watch_count = sum(1 for r in valid_results if r['prediction'] == 'watch')
                no_watch_count = len(valid_results) - watch_count
                avg_confidence = np.mean([r['confidence'] for r in valid_results])
                
                print(f"\nStatistiche:")
                print(f"  Immagini con orologi: {watch_count}")
                print(f"  Immagini senza orologi: {no_watch_count}")
                print(f"  Confidenza media: {avg_confidence:.2%}")
    
    except FileNotFoundError as e:
        print(f"Errore: {e}")
        print("Assicurati di aver addestrato il modello prima eseguendo:")
        print("  python train_watch_classifier.py")
        sys.exit(1)
    
    except Exception as e:
        print(f"Errore imprevisto: {e}")
        sys.exit(1)

if __name__ == "__main__":
    main()