import os
import requests
from PIL import Image
import matplotlib.pyplot as plt
import numpy as np
#from tqdm.notebook import tqdm (pas sur VS Code)
from tqdm import tqdm
import base64
import io

#ajout pour le token :
from dotenv import load_dotenv
load_dotenv()

True

#chemin vers les images
image_dir = "../assets/images/IMG"  

#Nombre max d'images à traiter (pour tester)
max_images = 50

#Token API Hugging Face (chargé depuis .env)
api_token = os.getenv("HF_TOKEN")

#Vérification 1 : dossier
if not os.path.exists(image_dir):
    raise FileNotFoundError(f"Le dossier '{image_dir}' n'existe pas.") 
else:
    print(f"Dossier '{image_dir}' existant.")

#verification 2 : token 
if not api_token:
    raise ValueError(
        "HF_TOKEN introuvable. Vérifie ton fichier .env et son contenu."
    )
else:
    print("Token Hugging Face chargé avec succès.")

#affichage
print(f"Dossier images : {image_dir}")
print(f"Nombre max d'images à traiter : {max_images}")

Dossier '../assets/images/IMG' existant.
Token Hugging Face chargé avec succès.
Dossier images : ../assets/images/IMG
Nombre max d'images à traiter : 50

API_URL = f"https://router.huggingface.co/hf-inference/models/sayeed99/segformer_b3_clothes"

headers = {
    "Authorization": f"Bearer {api_token}"
    # Le "Content-Type" sera ajouté dynamiquement lors de l'envoi de l'image
}

# Lister les chemins des images à traiter
# Assurez-vous d'avoir des images dans le dossier 'image_dir'!
image_paths = [
    os.path.join(image_dir,f)
    for f in os.listdir(image_dir)
    if f.lower().endswith((".jpg", ".png", ".jpeg"))
] [:max_images]

#verification
if not image_paths:
    print(f"Aucune image trouvée dans '{image_dir}'. Veuillez y ajouter des images.")
else:
    print(f"{len(image_paths)} image(s) à traiter : {image_paths}")

50 image(s) à traiter : ['../assets/images/IMG\\image_0.png', '../assets/images/IMG\\image_1.png', '../assets/images/IMG\\image_10.png', '../assets/images/IMG\\image_11.png', '../assets/images/IMG\\image_12.png', '../assets/images/IMG\\image_13.png', '../assets/images/IMG\\image_14.png', '../assets/images/IMG\\image_15.png', '../assets/images/IMG\\image_16.png', '../assets/images/IMG\\image_17.png', '../assets/images/IMG\\image_18.png', '../assets/images/IMG\\image_19.png', '../assets/images/IMG\\image_2.png', '../assets/images/IMG\\image_20.png', '../assets/images/IMG\\image_21.png', '../assets/images/IMG\\image_22.png', '../assets/images/IMG\\image_23.png', '../assets/images/IMG\\image_24.png', '../assets/images/IMG\\image_25.png', '../assets/images/IMG\\image_26.png', '../assets/images/IMG\\image_27.png', '../assets/images/IMG\\image_28.png', '../assets/images/IMG\\image_29.png', '../assets/images/IMG\\image_3.png', '../assets/images/IMG\\image_30.png', '../assets/images/IMG\\image_31.png', '../assets/images/IMG\\image_32.png', '../assets/images/IMG\\image_33.png', '../assets/images/IMG\\image_34.png', '../assets/images/IMG\\image_35.png', '../assets/images/IMG\\image_36.png', '../assets/images/IMG\\image_37.png', '../assets/images/IMG\\image_38.png', '../assets/images/IMG\\image_39.png', '../assets/images/IMG\\image_4.png', '../assets/images/IMG\\image_40.png', '../assets/images/IMG\\image_41.png', '../assets/images/IMG\\image_42.png', '../assets/images/IMG\\image_43.png', '../assets/images/IMG\\image_44.png', '../assets/images/IMG\\image_45.png', '../assets/images/IMG\\image_46.png', '../assets/images/IMG\\image_47.png', '../assets/images/IMG\\image_48.png', '../assets/images/IMG\\image_49.png', '../assets/images/IMG\\image_5.png', '../assets/images/IMG\\image_6.png', '../assets/images/IMG\\image_7.png', '../assets/images/IMG\\image_8.png', '../assets/images/IMG\\image_9.png']

CLASS_MAPPING = {
    "Background": 0,
    "Hat": 1,
    "Hair": 2,
    "Sunglasses": 3,
    "Upper-clothes": 4,
    "Skirt": 5,
    "Pants": 6,
    "Dress": 7,
    "Belt": 8,
    "Left-shoe": 9,
    "Right-shoe": 10,
    "Face": 11,
    "Left-leg": 12,
    "Right-leg": 13,
    "Left-arm": 14,
    "Right-arm": 15,
    "Bag": 16,
    "Scarf": 17
}

def get_image_dimensions(img_path):
    """
    Get the dimensions of an image.

    Args:
        img_path (str): Path to the image.

    Returns:
        tuple: (width, height) of the image.
    """
    original_image = Image.open(img_path)
    return original_image.size

def decode_base64_mask(base64_string, width, height):
    """
    Decode a base64-encoded mask into a NumPy array.

    Args:
        base64_string (str): Base64-encoded mask.
        width (int): Target width.
        height (int): Target height.

    Returns:
        np.ndarray: Single-channel mask array.
    """
    mask_data = base64.b64decode(base64_string)
    mask_image = Image.open(io.BytesIO(mask_data))
    mask_array = np.array(mask_image)
    if len(mask_array.shape) == 3:
        mask_array = mask_array[:, :, 0]  # Take first channel if RGB
    mask_image = Image.fromarray(mask_array).resize((width, height), Image.NEAREST)
    return np.array(mask_image)

def create_masks(results, width, height):
    """
    Combine multiple class masks into a single segmentation mask.

    Args:
        results (list): List of dictionaries with 'label' and 'mask' keys.
        width (int): Target width.
        height (int): Target height.

    Returns:
        np.ndarray: Combined segmentation mask with class indices.
    """
    combined_mask = np.zeros((height, width), dtype=np.uint8)  # Initialize with Background (0)

    # Process non-Background masks first
    for result in results:
        label = result['label']
        class_id = CLASS_MAPPING.get(label, 0)
        if class_id == 0:  # Skip Background
            continue
        mask_array = decode_base64_mask(result['mask'], width, height)
        combined_mask[mask_array > 0] = class_id

    # Process Background last to ensure it doesn't overwrite other classes unnecessarily
    # (Though the model usually provides non-overlapping masks for distinct classes other than background)
    for result in results:
        if result['label'] == 'Background':
            mask_array = decode_base64_mask(result['mask'], width, height)
            # Apply background only where no other class has been assigned yet
            # This logic might need adjustment based on how the model defines 'Background'
            # For this model, it seems safer to just let non-background overwrite it first.
            # A simple application like this should be fine: if Background mask says pixel is BG, set it to 0.
            # However, a more robust way might be to only set to background if combined_mask is still 0 (initial value)
            combined_mask[mask_array > 0] = 0 # Class ID for Background is 0

    return combined_mask

# Colormap personnalisé
# Palette stable : class_id -> (R, G, B)

custom_colormap = {
    0: (0, 0, 0),         # Background -> noir
    1: (255, 0, 0),       # Hat -> rouge
    2: (255, 128, 0),     # Hair -> orange
    3: (255, 255, 0),     # Sunglasses -> jaune
    4: (0, 128, 255),     # Upper-clothes -> bleu clair
    5: (255, 0, 255),     # Skirt -> magenta
    6: (0, 255, 255),     # Pants -> cyan
    7: (0, 255, 0),       # Dress -> vert
    8: (128, 64, 0),      # Belt -> marron
    9: (128, 128, 128),   # Left-shoe -> gris
    10:(128, 128, 128),   # Right-shoe -> gris 
    11:(200, 170, 140),   # Face -> peau (approx)
    12:(200, 170, 140),   # Left-leg -> peau (approx)
    13:(200, 170, 140),   # Right-leg -> peau (approx)
    14:(200, 170, 140),   # Left-arm -> peau (approx)
    15:(200, 170, 140),   # Right-arm -> peau (approx)
    16:(128, 0, 128),     # Bag -> violet
    17:(0, 100, 0),       # Scarf -> vert foncé
}

# Légendes associées aux labels
legend_labels = {
    "0": "Background",
    "1": "Hat",
    "2": "Hair",
    "3": "Sunglasses",
    "4": "Upper-clothes",
    "5": "Skirt",
    "6": "Pants",
    "7": "Dress",
    "8": "Belt",
    "9": "Left-shoe",
    "10": "Right-shoe",
    "11": "Face",
    "12": "Left-leg",
    "13": "Right-leg",
    "14": "Left-arm",
    "15": "Right-arm",
    "16": "Bag",
    "17": "Scarf"
}

# Fonctions pour coloriser le masque et ajouter la légende
def colorize_mask(mask, colormap):
    """
    Applique le colormap personnalisé au masque.
    Pour chaque pixel, s'il correspond à un label défini dans colormap,
    la couleur correspondante est assignée.
    """
    colored_mask = np.zeros((mask.shape[0], mask.shape[1], 3), dtype=np.uint8)
    for label, color in colormap.items():
        colored_mask[mask == label] = color
    return colored_mask

import matplotlib.patches as mpatches
def build_legend(colormap, labels):
    """
    Pour chaque classe définie dans le colormap, cette fonction crée un patch
    coloré avec le nom lisible de la classe, afin de pouvoir afficher une légende
    lors de la visualisation du masque segmenté. 
    """
    patches = []
    for class_id, color in colormap.items():
        label_name = labels.get(str(class_id), f"class {class_id}")
        color_norm = tuple(c / 255 for c in color)  #couleur comprehensible par matplotlib
        patches.append(
            mpatches.Patch(color=color_norm, label=label_name)
        )
    return patches


#récupération du masque réel d'une image 
from pathlib import Path
import re

def load_gt_mask_L(image_path, masks_dir="../assets/masks/Mask"):
    """
    Charge le masque réel associé à une image de type image_X.png -> mask_X.png
    Retourne None si le masque est introuvable (batch-safe).
    """
    image_path = Path(image_path)

    # Extraire l’index (ex: image_0.png → 0)
    match = re.search(r"(\d+)", image_path.stem)
    if match is None:
        print(f"[WARN] Index introuvable dans {image_path.name}")
        return None

    idx = match.group(1)
    mask_name = f"mask_{idx}.png"
    mask_path = Path(masks_dir) / mask_name

    if not mask_path.exists():
        print(f"[WARN] Masque réel introuvable : {mask_path}")
        return None
    
    mask = np.array(Image.open(mask_path))


    return mask



#verification de mes masques réels pour savoir si ma fonction "load_gt_mask_L" est bien adaptée à mon cas de masque
im = Image.open("../assets/masks/Mask/mask_0.png")
arr = np.array(im)

print("PIL mode:", im.mode)        # 'L', 'P', 'RGB', 'RGBA'...
print("shape:", arr.shape)         # (H,W) ou (H,W,3)
print("dtype:", arr.dtype)
print("unique (first 30):", np.unique(arr)[:30])
print("unique count:", len(np.unique(arr)))

PIL mode: L
shape: (600, 400)
dtype: uint8
unique (first 30): [ 0  2  4  6  9 10 11 12 13 15 16]
unique count: 11

MAX_W, MAX_H = 2000, 2000

if image_paths:
    # 1.Choisir une image
    single_image_path = image_paths[0] # Prenons la première image de notre liste
    print(f"Traitement de l'image : {single_image_path}")
    
    #verifier taille de l'image 
    with Image.open(single_image_path) as im:
        w, h = im.size
        if w > MAX_W or h > MAX_H:
            raise ValueError(f"Image trop grande: {w}x{h} (max {MAX_W}x{MAX_H}).")
    
    try:
        # 2. Lire l'image en binaire
        with open(single_image_path, "rb") as f:
            image_data = f.read()

        # 3. Content-Type selon extension 
        ext= single_image_path.lower()

        if ext.endswith(".png"):
            content_type = "image/png"
        elif ext.endswith((".jpg",".jpeg")):
            content_type = "image/jpeg"
        else :
            raise ValueError(f"Format d'image non supporté : {single_image_path}")

        headers["Content-Type"]= content_type

        # 4. Requête API
        response = requests.post(API_URL, headers=headers, data=image_data, timeout=(5, 60))  

        # 5. Vérification du statut HTTP
        response.raise_for_status()

        # 6. Convertir la réponse JSON 
        result = response.json()

        # 7. Construire le masque final (en utilisant les fonctions utilitaires pour le traitement des masques)
        w, h = get_image_dimensions(single_image_path)
        combined_mask= create_masks(result,w,h)

        # 8. Affichage de l'image d'origine et de l'image segmentée
        img= Image.open(single_image_path).convert("RGB")

        plt.figure(figsize=(15,5))
        plt.subplot(1,3,1)
        plt.title("Image originale")
        plt.imshow(img)
        plt.axis("off")

        colored_mask = colorize_mask(combined_mask, custom_colormap)

        plt.subplot(1,3,2)
        plt.title("Masque de segmentation (prédit)")
        plt.imshow(colored_mask)
        plt.axis("off")

        legend_patches = build_legend(custom_colormap, legend_labels)
        plt.legend(handles=legend_patches,bbox_to_anchor=(1.05, 1),loc="upper left",borderaxespad=0.,fontsize=10)

        #masque réel
        gt_mask = load_gt_mask_L(single_image_path)
        gt_colored = colorize_mask(gt_mask, custom_colormap)

        plt.subplot(1,3,3)
        plt.title("Masque de segmentation (réel)")
        plt.imshow(gt_colored)
        plt.axis("off")

        plt.show() 
        #plt.close("all")


    except Exception as e:
        print(f"Une erreur est survenue : {e}")
else:
    print("Aucune image à traiter. Vérifiez la configuration de 'image_dir' et 'max_images'.")

import time 
from io import BytesIO

def resize_for_api(img: Image.Image, max_size=1024):
    w, h = img.size
    if max(w, h) <= max_size:
        return img
    ratio = max_size / max(w, h)
    return img.resize((int(w*ratio), int(h*ratio)), Image.BILINEAR)

def segment_images_batch(list_of_image_paths, sleep_s=0.3):
    """
    Segmente une liste d'images en utilisant l'API Hugging Face.

    Args:
        list_of_image_paths (list): Liste des chemins vers les images.
        sleep_s (float): pause entre appel API (évite rate-limit/surcharge)

    Returns:
        list: Liste des masques de segmentation (tableaux NumPy).
              Contient None si une image n'a pas pu être traitée.
    """
    
    batch_segmentations = []

    for img_path in tqdm(list_of_image_paths, desc="Segmentation en batch"):
        try:
            # 0. Verifier taille de l'image 
            with Image.open(img_path) as im:
                im = im.convert("RGB")  # optionnel mais évite des soucis (mode P/RGBA)
                im = resize_for_api(im, max_size=1024)

            # 1. Lire l'image en binaire
            buf = BytesIO()
            ext = img_path.lower()
            fmt = "PNG" if ext.endswith(".png") else "JPEG" 
            im.save(buf, format=fmt)
            image_data = buf.getvalue()
            
            # 2. Content-Type selon extension 
            content_type = "image/png" if fmt == "PNG" else "image/jpeg"

            # 3. Préparer headers (copie pour éviter effets de bords)
            local_headers = headers.copy()
            local_headers["Content-Type"]= content_type

            # 4. Requête API
            response = requests.post(API_URL, headers=local_headers, data=image_data, timeout=(5, 60) )  # (5,60) -> (connect_timeout, read_timeout)

            # 5. Vérification du statut HTTP
            response.raise_for_status()

            # 6. Convertir la réponse JSON 
            result = response.json()

            # 7. Construire le masque final
            w, h = im.size
            combined_mask= create_masks(result,w,h)
  
            # 8. Ajout 
            batch_segmentations.append(combined_mask)


        except Exception as e:
            print(f"[ERREUR] {img_path} -> {e}")
            batch_segmentations.append(None)

        # 9. Petite pause entre appels 
        time.sleep(sleep_s)    


    return batch_segmentations




# Appeler la fonction pour segmenter les images listées dans image_paths
if image_paths:
    print(f"\nTraitement de {len(image_paths)} image(s) en batch...")
    batch_seg_results = segment_images_batch(image_paths)
    print("Traitement en batch terminé.")
else:
    batch_seg_results = []
    print("Aucune image à traiter en batch.")

Traitement de 50 image(s) en batch...

Segmentation en batch: 100%|██████████| 50/50 [01:53<00:00,  2.27s/it]

Traitement en batch terminé.

import math


def display_segmented_images_batch(original_image_paths, segmentation_masks):
    """
    Affiche les images originales et leurs masques segmentés.

    Args:
        original_image_paths (list): Liste des chemins des images originales.
        segmentation_masks (list): Liste des masques segmentés (NumPy arrays).
    """
    
    # On garde uniquement les paires valides (mask != None)
    pairs = [(p, m) for p, m in zip(original_image_paths, segmentation_masks) if m is not None]

    if not pairs:
        print("Aucun masque valide à afficher.")
        return

    n = len(pairs)
    nrows = n
    ncols = 3  # image / masque prédit / masque réel

    plt.figure(figsize=(10, 6 * nrows))

    for i, (img_path, mask) in enumerate(pairs):
        # image originale
        ax1 = plt.subplot(nrows, ncols, i * 3 + 1)
        img = Image.open(img_path).convert("RGB")
        ax1.imshow(img)
        ax1.set_title(f"Image {i+1}")
        ax1.axis("off")

        # masque prédit
        colored_mask = colorize_mask(mask, custom_colormap)
        ax2 = plt.subplot(nrows, ncols, i * 3 + 2)
        ax2.imshow(colored_mask)
        ax2.set_title("Masque prédit")
        legend_patches = build_legend(custom_colormap, legend_labels)
        plt.legend(handles=legend_patches,bbox_to_anchor=(1.05, 1),loc="upper left",borderaxespad=0., fontsize=8)
        ax2.axis("off")

        #masque réel
        gt_mask = load_gt_mask_L(img_path)
        ax3 = plt.subplot(nrows, ncols, i * 3 + 3)
        if gt_mask is not None:
            gt_colored = colorize_mask(gt_mask, custom_colormap)
            ax3.imshow(gt_colored)
            ax3.set_title("Masque réel")
        else:
            plt.text(0.5, 0.5, "Masque réel manquant", ha="center", va="center")
        ax3.axis("off")


    plt.tight_layout()
    plt.show()
    #plt.close("all")





# Afficher les résultats du batch
if batch_seg_results:
    display_segmented_images_batch(image_paths, batch_seg_results)
else:
    print("Aucun résultat de segmentation à afficher.")

#verification 
print("len(image_paths) =", len(image_paths))
print("max_images =", max_images)

print("images =", len(image_paths))
print("masks =", len(batch_seg_results))
print("valid =", sum(m is not None for m in batch_seg_results))
print("none  =", sum(m is None for m in batch_seg_results))

len(image_paths) = 50
max_images = 50
images = 50
masks = 50
valid = 50
none  = 0

#verification taille masque GT = taille masque prédit . si ok on pourra directement utiliser IoU
for p, pred in zip(image_paths, batch_seg_results):
    if pred is None:
        continue
    gt = load_gt_mask_L(p)
    if gt is None:
        continue
    print("pred:", pred.shape, "gt:", gt.shape, "file:", p)
    break

pred: (600, 400) gt: (600, 400) file: ../assets/images/IMG\image_0.png

import random

def split_paths(paths, seed=42, train_n=30, val_n=10, test_n=10):
    """ 
    Sépare une liste de chemins d'images en 3 sous-ensembles : entrainement/validation/test
    """
    paths = list(paths)
    random.Random(seed).shuffle(paths)
    train = paths[:train_n]
    val   = paths[train_n:train_n+val_n]
    test  = paths[train_n+val_n:train_n+val_n+test_n]
    return train, val, test


def iou_per_class(pred, gt, num_classes=18): 
    """
    calcul l'Intersection over Union (IoU) pour chaque classe présente entre un masque prédit et un masque réel. 
    """
    ious = {}
    for c in range(num_classes):
        pred_c = (pred == c)
        gt_c   = (gt == c)

        inter = np.logical_and(pred_c, gt_c).sum()
        union = np.logical_or(pred_c, gt_c).sum()

        ious[c] = np.nan if union == 0 else inter / union
    return ious

def miou_from_ious(ious_dict):
    """  
    calcul le mean IoU 0 PARTIR DES IoU par classe
    """
    vals = [v for v in ious_dict.values() if not np.isnan(v)]
    return float(np.mean(vals)) if vals else np.nan

def build_pred_by_path(image_paths, batch_segmentations):
    """  
    Associe chaque image à son masque prédit correspondant
    """
    return {p: m for p, m in zip(image_paths, batch_segmentations) if m is not None}

def evaluate_on_test(test_paths, pred_by_path, num_classes=18):
    """  
    Evalue les performances du modèle sur le jeu de test en calculant le mIoU moyen sur toutes les images valides"""
    per_image_miou = []
    per_class_vals = {c: [] for c in range(num_classes)}
    n_used = 0

    for p in test_paths:
        pred = pred_by_path.get(p)
        if pred is None:
            continue

        gt = load_gt_mask_L(p)
        if gt is None:
            continue

        # si shapes différents, on ne calcule pas (au cas où)
        if pred.shape != gt.shape:
            print(f"[SKIP shape mismatch] pred={pred.shape} gt={gt.shape} -> {p}")
            continue

        ious = iou_per_class(pred, gt, num_classes=num_classes)
        per_image_miou.append(miou_from_ious(ious))

        for c, v in ious.items():
            if not np.isnan(v):
                per_class_vals[c].append(v)

        n_used += 1

    miou_global = float(np.mean(per_image_miou)) if per_image_miou else np.nan
    miou_per_class = {c: (float(np.mean(v)) if v else np.nan) for c, v in per_class_vals.items()}

    return miou_global, miou_per_class, n_used

train_paths, val_paths, test_paths = split_paths(image_paths, seed=42)

pred_by_path = build_pred_by_path(image_paths, batch_seg_results)

miou_global, miou_per_class, n_used = evaluate_on_test(test_paths, pred_by_path)

print("Nb images test utilisées:", n_used, "/", len(test_paths))
print("mIoU global (test):", miou_global)

Nb images test utilisées: 10 / 10
mIoU global (test): 0.5851445874187551

# tri en ignorant NaN
items = [(c, v) for c, v in miou_per_class.items() if not np.isnan(v)]
items_sorted = sorted(items, key=lambda x: x[1], reverse=True)

print("Top 5 classes (IoU):", items_sorted[:5])
print("Flop 5 classes (IoU):", items_sorted[-5:])

Top 5 classes (IoU): [(0, 0.9808970297516758), (5, 0.9397323917335844), (7, 0.9296819218931693), (4, 0.9048105778156871), (6, 0.9026475292086987)]
Flop 5 classes (IoU): [(9, 0.33373009101238077), (12, 0.26962102223341616), (14, 0.2558407514635559), (13, 0.14107514680998134), (10, 0.07210873468070322)]

Notebook : Segmentation d'image¶

1. Configuration Initiale et Importations¶

Variables de Configuration¶

2. Comprendre l'API d'Inférence Hugging Face¶

3. Fonctions Utilitaires pour le Traitement des Masques¶

Fonctions utilitaires pour affichage :¶

4. Segmentation d'une Seule Image¶

5. Segmentation de Plusieurs Images (Batch)¶

6. Affichage des Résultats en Batch¶

7. Analyse des performances du modèle sur les 50 images¶

8. Méthode de validation du modèle¶

Coût d'utilisation :¶

L'agence souhaite avoir une idée sur l'estimation du coût pour le traitement de 500.000 images en 30 jours.¶

Pistes d'amélioration ou d'exploration :¶

Note sur l’affichage des résultats¶