Finger_print_preproced.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "!pip install rembg[gpu] opencv-python-headless pillow tqdm onnxruntime"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mzMbPGrmcntQ",
        "outputId": "88a9177b-793b-4dae-f666-72e440e74acc"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: opencv-python-headless in /usr/local/lib/python3.11/dist-packages (4.11.0.86)\n",
            "Requirement already satisfied: pillow in /usr/local/lib/python3.11/dist-packages (11.2.1)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.11/dist-packages (4.67.1)\n",
            "Collecting onnxruntime\n",
            "  Downloading onnxruntime-1.22.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl.metadata (4.5 kB)\n",
            "Collecting rembg[gpu]\n",
            "  Downloading rembg-2.0.66-py3-none-any.whl.metadata (21 kB)\n",
            "Requirement already satisfied: jsonschema in /usr/local/lib/python3.11/dist-packages (from rembg[gpu]) (4.24.0)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.11/dist-packages (from rembg[gpu]) (2.0.2)\n",
            "Requirement already satisfied: pooch in /usr/local/lib/python3.11/dist-packages (from rembg[gpu]) (1.8.2)\n",
            "Collecting pymatting (from rembg[gpu])\n",
            "  Downloading pymatting-1.1.14-py3-none-any.whl.metadata (7.7 kB)\n",
            "Requirement already satisfied: scikit-image in /usr/local/lib/python3.11/dist-packages (from rembg[gpu]) (0.25.2)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.11/dist-packages (from rembg[gpu]) (1.15.3)\n",
            "Collecting onnxruntime-gpu (from rembg[gpu])\n",
            "  Downloading onnxruntime_gpu-1.22.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl.metadata (4.9 kB)\n",
            "Collecting coloredlogs (from onnxruntime)\n",
            "  Downloading coloredlogs-15.0.1-py2.py3-none-any.whl.metadata (12 kB)\n",
            "Requirement already satisfied: flatbuffers in /usr/local/lib/python3.11/dist-packages (from onnxruntime) (25.2.10)\n",
            "Requirement already satisfied: packaging in /usr/local/lib/python3.11/dist-packages (from onnxruntime) (24.2)\n",
            "Requirement already satisfied: protobuf in /usr/local/lib/python3.11/dist-packages (from onnxruntime) (5.29.5)\n",
            "Requirement already satisfied: sympy in /usr/local/lib/python3.11/dist-packages (from onnxruntime) (1.13.1)\n",
            "Collecting humanfriendly>=9.1 (from coloredlogs->onnxruntime)\n",
            "  Downloading humanfriendly-10.0-py2.py3-none-any.whl.metadata (9.2 kB)\n",
            "Requirement already satisfied: attrs>=22.2.0 in /usr/local/lib/python3.11/dist-packages (from jsonschema->rembg[gpu]) (25.3.0)\n",
            "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /usr/local/lib/python3.11/dist-packages (from jsonschema->rembg[gpu]) (2025.4.1)\n",
            "Requirement already satisfied: referencing>=0.28.4 in /usr/local/lib/python3.11/dist-packages (from jsonschema->rembg[gpu]) (0.36.2)\n",
            "Requirement already satisfied: rpds-py>=0.7.1 in /usr/local/lib/python3.11/dist-packages (from jsonschema->rembg[gpu]) (0.25.1)\n",
            "Requirement already satisfied: platformdirs>=2.5.0 in /usr/local/lib/python3.11/dist-packages (from pooch->rembg[gpu]) (4.3.8)\n",
            "Requirement already satisfied: requests>=2.19.0 in /usr/local/lib/python3.11/dist-packages (from pooch->rembg[gpu]) (2.32.3)\n",
            "Requirement already satisfied: numba!=0.49.0 in /usr/local/lib/python3.11/dist-packages (from pymatting->rembg[gpu]) (0.60.0)\n",
            "Requirement already satisfied: networkx>=3.0 in /usr/local/lib/python3.11/dist-packages (from scikit-image->rembg[gpu]) (3.5)\n",
            "Requirement already satisfied: imageio!=2.35.0,>=2.33 in /usr/local/lib/python3.11/dist-packages (from scikit-image->rembg[gpu]) (2.37.0)\n",
            "Requirement already satisfied: tifffile>=2022.8.12 in /usr/local/lib/python3.11/dist-packages (from scikit-image->rembg[gpu]) (2025.6.11)\n",
            "Requirement already satisfied: lazy-loader>=0.4 in /usr/local/lib/python3.11/dist-packages (from scikit-image->rembg[gpu]) (0.4)\n",
            "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy->onnxruntime) (1.3.0)\n",
            "Requirement already satisfied: llvmlite<0.44,>=0.43.0dev0 in /usr/local/lib/python3.11/dist-packages (from numba!=0.49.0->pymatting->rembg[gpu]) (0.43.0)\n",
            "Requirement already satisfied: typing-extensions>=4.4.0 in /usr/local/lib/python3.11/dist-packages (from referencing>=0.28.4->jsonschema->rembg[gpu]) (4.14.0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests>=2.19.0->pooch->rembg[gpu]) (3.4.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests>=2.19.0->pooch->rembg[gpu]) (3.10)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests>=2.19.0->pooch->rembg[gpu]) (2.4.0)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests>=2.19.0->pooch->rembg[gpu]) (2025.6.15)\n",
            "Downloading onnxruntime-1.22.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (16.4 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m16.4/16.4 MB\u001b[0m \u001b[31m68.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading coloredlogs-15.0.1-py2.py3-none-any.whl (46 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m46.0/46.0 kB\u001b[0m \u001b[31m3.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading onnxruntime_gpu-1.22.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl (283.2 MB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m283.2/283.2 MB\u001b[0m \u001b[31m6.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading pymatting-1.1.14-py3-none-any.whl (54 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m54.7/54.7 kB\u001b[0m \u001b[31m4.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading rembg-2.0.66-py3-none-any.whl (41 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m41.7/41.7 kB\u001b[0m \u001b[31m2.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hDownloading humanfriendly-10.0-py2.py3-none-any.whl (86 kB)\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m86.8/86.8 kB\u001b[0m \u001b[31m6.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hInstalling collected packages: humanfriendly, pymatting, coloredlogs, onnxruntime-gpu, onnxruntime, rembg\n",
            "Successfully installed coloredlogs-15.0.1 humanfriendly-10.0 onnxruntime-1.22.0 onnxruntime-gpu-1.22.0 pymatting-1.1.14 rembg-2.0.66\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HKYwL78egwwZ",
        "outputId": "af67d853-0f86-4b1f-b4be-a09bcb1b2c97"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "c311ZPEYb0wH",
        "outputId": "75c250d4-9dc8-4aed-ff4f-fe39c82633a3"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "=== PRÉPROCESSING DES EMPREINTES DIGITALES ===\n",
            "Dossier d'entrée: /content/drive/MyDrive/DATA\n",
            "Dossier de sortie: /content/processed_fingerprints_structured\n",
            "Taille cible: (128, 128)\n",
            "Compatible VGG16: True\n",
            "\n",
            "=== ANALYSE DE LA STRUCTURE DU DOSSIER ===\n",
            "Total d'images trouvées: 2100\n",
            "Répartition par dossier:\n",
            "  LANDRY: 210 images\n",
            "  DIVINE: 210 images\n",
            "  JOEL: 210 images\n",
            "  MAURICE: 210 images\n",
            "  NATHANAEL: 210 images\n",
            "  WILSON: 210 images\n",
            "  LONTSI: 210 images\n",
            "  DANILO: 210 images\n",
            "  KETSIA: 210 images\n",
            "  PATRICE: 210 images\n",
            "Traitement de 2100 images...\n",
            "Structure de dossiers préservée: /content/drive/MyDrive/DATA -> /content/processed_fingerprints_structured/processed_with_structure\n",
            "Mode VGG16 : Images en RGB avec taille personnalisée\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\rTraitement des images:   0%|          | 0/2100 [00:00<?, ?it/s]Downloading data from 'https://github.com/danielgatis/rembg/releases/download/v0.0.0/u2net.onnx' to file '/root/.u2net/u2net.onnx'.\n",
            "\n",
            "  0%|                                               | 0.00/176M [00:00<?, ?B/s]\u001b[A\n",
            "  0%|                                       | 80.9k/176M [00:00<04:27, 656kB/s]\u001b[A\n",
            "  0%|                                       | 392k/176M [00:00<01:28, 1.97MB/s]\u001b[A\n",
            "  1%|▍                                     | 1.78M/176M [00:00<00:27, 6.27MB/s]\u001b[A\n",
            "  1%|▌                                     | 2.48M/176M [00:00<00:27, 6.28MB/s]\u001b[A\n",
            "  3%|▉                                     | 4.59M/176M [00:00<00:15, 11.1MB/s]\u001b[A\n",
            "  6%|██                                    | 9.76M/176M [00:00<00:06, 24.0MB/s]\u001b[A\n",
            "  9%|███▍                                  | 16.0M/176M [00:00<00:04, 36.0MB/s]\u001b[A\n",
            " 13%|████▊                                 | 22.3M/176M [00:00<00:03, 44.2MB/s]\u001b[A\n",
            " 17%|██████▎                               | 29.2M/176M [00:00<00:02, 51.8MB/s]\u001b[A\n",
            " 20%|███████▌                              | 35.1M/176M [00:01<00:02, 54.0MB/s]\u001b[A\n",
            " 24%|████████▉                             | 41.6M/176M [00:01<00:02, 57.4MB/s]\u001b[A\n",
            " 27%|██████████▎                           | 47.6M/176M [00:01<00:02, 58.4MB/s]\u001b[A\n",
            " 30%|███████████▌                          | 53.6M/176M [00:01<00:02, 58.7MB/s]\u001b[A\n",
            " 34%|████████████▊                         | 59.5M/176M [00:01<00:02, 56.3MB/s]\u001b[A\n",
            " 37%|██████████████▏                       | 65.9M/176M [00:01<00:01, 58.4MB/s]\u001b[A\n",
            " 41%|███████████████▌                      | 72.0M/176M [00:01<00:01, 59.1MB/s]\u001b[A\n",
            " 44%|████████████████▉                     | 78.2M/176M [00:01<00:01, 60.1MB/s]\u001b[A\n",
            " 48%|██████████████████▎                   | 84.9M/176M [00:01<00:01, 62.3MB/s]\u001b[A\n",
            " 52%|███████████████████▊                  | 91.5M/176M [00:01<00:01, 63.4MB/s]\u001b[A\n",
            " 56%|█████████████████████▏                | 98.3M/176M [00:02<00:01, 64.6MB/s]\u001b[A\n",
            " 60%|███████████████████████▎               | 105M/176M [00:02<00:01, 65.8MB/s]\u001b[A\n",
            " 64%|████████████████████████▊              | 112M/176M [00:02<00:00, 67.0MB/s]\u001b[A\n",
            " 68%|██████████████████████████▎            | 119M/176M [00:02<00:00, 58.7MB/s]\u001b[A\n",
            " 71%|███████████████████████████▋           | 125M/176M [00:02<00:01, 45.8MB/s]\u001b[A\n",
            " 74%|████████████████████████████▊          | 130M/176M [00:02<00:01, 42.8MB/s]\u001b[A\n",
            " 77%|█████████████████████████████▊         | 135M/176M [00:02<00:00, 42.4MB/s]\u001b[A\n",
            " 79%|██████████████████████████████▊        | 139M/176M [00:03<00:00, 39.9MB/s]\u001b[A\n",
            " 81%|███████████████████████████████▊       | 143M/176M [00:03<00:00, 40.1MB/s]\u001b[A\n",
            " 84%|████████████████████████████████▋      | 148M/176M [00:03<00:00, 40.9MB/s]\u001b[A\n",
            " 86%|█████████████████████████████████▋     | 152M/176M [00:03<00:00, 41.4MB/s]\u001b[A\n",
            " 89%|██████████████████████████████████▌    | 156M/176M [00:03<00:00, 41.9MB/s]\u001b[A\n",
            " 91%|███████████████████████████████████▌   | 160M/176M [00:03<00:00, 41.0MB/s]\u001b[A\n",
            " 94%|████████████████████████████████████▍  | 165M/176M [00:03<00:00, 39.9MB/s]\u001b[A\n",
            " 96%|█████████████████████████████████████▍ | 169M/176M [00:03<00:00, 41.2MB/s]\u001b[A\n",
            " 99%|██████████████████████████████████████▍| 174M/176M [00:03<00:00, 42.3MB/s]\u001b[A\n",
            "100%|███████████████████████████████████████| 176M/176M [00:00<00:00, 65.3GB/s]\n",
            "Traitement des images:  18%|█▊        | 376/2100 [23:59<2:12:56,  4.63s/it]"
          ]
        }
      ],
      "source": [
        "import os\n",
        "import cv2\n",
        "import numpy as np\n",
        "from PIL import Image\n",
        "import zipfile\n",
        "from rembg import remove\n",
        "from tqdm import tqdm\n",
        "import shutil\n",
        "from google.colab import files\n",
        "import io\n",
        "\n",
        "def get_all_image_files_with_structure(folder_path):\n",
        "    \"\"\"\n",
        "    Récupère tous les fichiers d'images dans un dossier en préservant la structure\n",
        "    Retourne une liste de tuples (chemin_complet, chemin_relatif)\n",
        "    \"\"\"\n",
        "    supported_formats = ('.png', '.jpg', '.jpeg', '.bmp', '.tiff', '.tif')\n",
        "    image_files = []\n",
        "\n",
        "    for root, dirs, files in os.walk(folder_path):\n",
        "        for file in files:\n",
        "            if file.lower().endswith(supported_formats):\n",
        "                full_path = os.path.join(root, file)\n",
        "                relative_path = os.path.relpath(full_path, folder_path)\n",
        "                image_files.append((full_path, relative_path))\n",
        "\n",
        "    return image_files\n",
        "\n",
        "def resize_image(image, target_size=(224, 224)):\n",
        "    \"\"\"\n",
        "    Redimensionne l'image à la taille cible (224x224 pour VGG16)\n",
        "    \"\"\"\n",
        "    if isinstance(image, Image.Image):\n",
        "        return image.resize(target_size, Image.Resampling.LANCZOS)\n",
        "    else:\n",
        "        return cv2.resize(image, target_size, interpolation=cv2.INTER_LANCZOS4)\n",
        "\n",
        "def enhance_contrast_histogram_equalization(image, keep_rgb=True):\n",
        "    \"\"\"\n",
        "    Améliore le contraste avec égalisation d'histogramme\n",
        "    Garde les 3 canaux RGB pour VGG16 si keep_rgb=True\n",
        "    \"\"\"\n",
        "    if isinstance(image, Image.Image):\n",
        "        img_array = np.array(image)\n",
        "\n",
        "        if keep_rgb and len(img_array.shape) == 3:\n",
        "            # Appliquer CLAHE sur chaque canal RGB séparément\n",
        "            img_enhanced = np.zeros_like(img_array)\n",
        "            clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))\n",
        "\n",
        "            for i in range(3):  # Pour chaque canal RGB\n",
        "                img_enhanced[:, :, i] = clahe.apply(img_array[:, :, i])\n",
        "\n",
        "            return Image.fromarray(img_enhanced)\n",
        "        else:\n",
        "            # Version originale pour niveaux de gris\n",
        "            if len(img_array.shape) == 3:\n",
        "                img_gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)\n",
        "            else:\n",
        "                img_gray = img_array\n",
        "            clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))\n",
        "            img_enhanced = clahe.apply(img_gray)\n",
        "            return Image.fromarray(img_enhanced)\n",
        "    else:\n",
        "        if keep_rgb and len(image.shape) == 3:\n",
        "            img_enhanced = np.zeros_like(image)\n",
        "            clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))\n",
        "\n",
        "            for i in range(3):\n",
        "                img_enhanced[:, :, i] = clahe.apply(image[:, :, i])\n",
        "\n",
        "            return img_enhanced\n",
        "        else:\n",
        "            if len(image.shape) == 3:\n",
        "                img_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\n",
        "            else:\n",
        "                img_gray = image\n",
        "            clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8, 8))\n",
        "            img_enhanced = clahe.apply(img_gray)\n",
        "            return img_enhanced\n",
        "\n",
        "def ensure_rgb_format(image):\n",
        "    \"\"\"\n",
        "    S'assure que l'image est en format RGB 3 canaux pour VGG16\n",
        "    \"\"\"\n",
        "    if isinstance(image, Image.Image):\n",
        "        if image.mode == 'L':  # Niveaux de gris\n",
        "            return image.convert('RGB')\n",
        "        elif image.mode == 'RGBA':  # Avec canal alpha\n",
        "            return image.convert('RGB')\n",
        "        else:\n",
        "            return image\n",
        "    else:\n",
        "        if len(image.shape) == 2:  # Niveaux de gris\n",
        "            return cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)\n",
        "        elif image.shape[2] == 4:  # RGBA\n",
        "            return cv2.cvtColor(image, cv2.COLOR_RGBA2RGB)\n",
        "        else:\n",
        "            return image\n",
        "\n",
        "def remove_background_rembg(image):\n",
        "    \"\"\"\n",
        "    Supprime le fond de l'image avec rembg\n",
        "    \"\"\"\n",
        "    if not isinstance(image, Image.Image):\n",
        "        if len(image.shape) == 2:\n",
        "            image = Image.fromarray(image).convert('RGB')\n",
        "        else:\n",
        "            image = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))\n",
        "\n",
        "    image_no_bg = remove(image)\n",
        "\n",
        "    # Convertir RGBA vers RGB avec fond blanc pour VGG16\n",
        "    if image_no_bg.mode == 'RGBA':\n",
        "        background = Image.new('RGB', image_no_bg.size, (255, 255, 255))  # Fond blanc\n",
        "        background.paste(image_no_bg, mask=image_no_bg.split()[-1])  # Utiliser canal alpha comme masque\n",
        "        return background\n",
        "\n",
        "    return image_no_bg\n",
        "\n",
        "def process_single_image_with_structure(image_path, output_folder, relative_path,\n",
        "                                       target_size=(224, 224), vgg16_compatible=True):\n",
        "    \"\"\"\n",
        "    Traite une seule image en préservant sa position dans la structure de dossiers\n",
        "    \"\"\"\n",
        "    try:\n",
        "        image = Image.open(image_path)\n",
        "\n",
        "        # Redimensionnement\n",
        "        image_resized = resize_image(image, target_size)\n",
        "\n",
        "        # Amélioration du contraste (garde RGB si compatible VGG16)\n",
        "        image_enhanced = enhance_contrast_histogram_equalization(\n",
        "            image_resized, keep_rgb=vgg16_compatible\n",
        "        )\n",
        "\n",
        "        # Suppression du fond\n",
        "        image_no_bg = remove_background_rembg(image_enhanced)\n",
        "\n",
        "        # S'assurer du format RGB pour VGG16\n",
        "        if vgg16_compatible:\n",
        "            image_no_bg = ensure_rgb_format(image_no_bg)\n",
        "\n",
        "        # Créer la structure de dossiers de sortie\n",
        "        output_dir = os.path.dirname(os.path.join(output_folder, relative_path))\n",
        "        os.makedirs(output_dir, exist_ok=True)\n",
        "\n",
        "        # Changer l'extension en .png pour uniformiser\n",
        "        base_name = os.path.splitext(os.path.basename(relative_path))[0]\n",
        "        output_relative_path = os.path.join(os.path.dirname(relative_path), f\"{base_name}.png\")\n",
        "        output_path = os.path.join(output_folder, output_relative_path)\n",
        "\n",
        "        # Sauvegarde\n",
        "        image_no_bg.save(output_path, \"PNG\")\n",
        "\n",
        "        return output_path, True\n",
        "    except Exception as e:\n",
        "        print(f\"Erreur lors du traitement de {image_path}: {str(e)}\")\n",
        "        return None, False\n",
        "\n",
        "def process_folder_with_structure(input_folder, output_folder,\n",
        "                                 target_size=(224, 224), vgg16_compatible=True):\n",
        "    \"\"\"\n",
        "    Traite toutes les images d'un dossier en préservant la structure\n",
        "    \"\"\"\n",
        "    os.makedirs(output_folder, exist_ok=True)\n",
        "    image_files = get_all_image_files_with_structure(input_folder)\n",
        "\n",
        "    if not image_files:\n",
        "        print(f\"Aucune image trouvée dans {input_folder}\")\n",
        "        return []\n",
        "\n",
        "    print(f\"Traitement de {len(image_files)} images...\")\n",
        "    print(f\"Structure de dossiers préservée: {input_folder} -> {output_folder}\")\n",
        "    if vgg16_compatible:\n",
        "        print(\"Mode VGG16 : Images en RGB avec taille personnalisée\")\n",
        "\n",
        "    processed_files = []\n",
        "    successful_count = 0\n",
        "\n",
        "    for image_path, relative_path in tqdm(image_files, desc=\"Traitement des images\"):\n",
        "        output_path, success = process_single_image_with_structure(\n",
        "            image_path, output_folder, relative_path, target_size, vgg16_compatible\n",
        "        )\n",
        "        if success:\n",
        "            processed_files.append(output_path)\n",
        "            successful_count += 1\n",
        "\n",
        "    print(f\"Traitement terminé: {successful_count}/{len(image_files)} images traitées avec succès\")\n",
        "    return processed_files\n",
        "\n",
        "def create_zip_archive(folder_path, zip_filename):\n",
        "    \"\"\"\n",
        "    Crée une archive ZIP du dossier traité et la rend téléchargeable\n",
        "    \"\"\"\n",
        "    try:\n",
        "        with zipfile.ZipFile(zip_filename, 'w', zipfile.ZIP_DEFLATED) as zipf:\n",
        "            for root, dirs, files in os.walk(folder_path):\n",
        "                for file in files:\n",
        "                    file_path = os.path.join(root, file)\n",
        "                    arcname = os.path.relpath(file_path, folder_path)\n",
        "                    zipf.write(file_path, arcname)\n",
        "        print(f\"Archive ZIP créée: {zip_filename}\")\n",
        "        files.download(zip_filename)\n",
        "        return True\n",
        "    except Exception as e:\n",
        "        print(f\"Erreur lors de la création de l'archive ZIP: {str(e)}\")\n",
        "        return False\n",
        "\n",
        "def analyze_folder_structure(input_folder):\n",
        "    \"\"\"\n",
        "    Analyse et affiche la structure du dossier d'entrée\n",
        "    \"\"\"\n",
        "    print(\"\\n=== ANALYSE DE LA STRUCTURE DU DOSSIER ===\")\n",
        "    structure_info = {}\n",
        "    total_images = 0\n",
        "\n",
        "    for root, dirs, files in os.walk(input_folder):\n",
        "        relative_path = os.path.relpath(root, input_folder)\n",
        "        if relative_path == '.':\n",
        "            relative_path = 'racine'\n",
        "\n",
        "        image_count = sum(1 for f in files if f.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.tiff', '.tif')))\n",
        "        if image_count > 0:\n",
        "            structure_info[relative_path] = image_count\n",
        "            total_images += image_count\n",
        "\n",
        "    print(f\"Total d'images trouvées: {total_images}\")\n",
        "    print(\"Répartition par dossier:\")\n",
        "    for folder, count in structure_info.items():\n",
        "        print(f\"  {folder}: {count} images\")\n",
        "\n",
        "    return structure_info\n",
        "\n",
        "def preprocess_fingerprints_complete(input_folder=\"/content/drive/MyDrive/DATA\",\n",
        "                                   output_base_folder=\"/content/processed_fingerprints\",\n",
        "                                   target_size=(224, 224),\n",
        "                                   vgg16_compatible=True,\n",
        "                                   create_zip=True,\n",
        "                                   cleanup_temp=False):\n",
        "    \"\"\"\n",
        "    Fonction principale pour le préprocessing complet des empreintes digitales\n",
        "    Préserve la structure de dossiers originale\n",
        "    \"\"\"\n",
        "    print(\"=== PRÉPROCESSING DES EMPREINTES DIGITALES ===\")\n",
        "    print(f\"Dossier d'entrée: {input_folder}\")\n",
        "    print(f\"Dossier de sortie: {output_base_folder}\")\n",
        "    print(f\"Taille cible: {target_size}\")\n",
        "    print(f\"Compatible VGG16: {vgg16_compatible}\")\n",
        "\n",
        "    if not os.path.exists(input_folder):\n",
        "        print(f\"Erreur: Le dossier {input_folder} n'existe pas\")\n",
        "        return False\n",
        "\n",
        "    # Analyser la structure du dossier d'entrée\n",
        "    analyze_folder_structure(input_folder)\n",
        "\n",
        "    os.makedirs(output_base_folder, exist_ok=True)\n",
        "    temp_folder = os.path.join(output_base_folder, \"processed_with_structure\")\n",
        "\n",
        "    processed_files = process_folder_with_structure(input_folder, temp_folder,\n",
        "                                                   target_size, vgg16_compatible)\n",
        "\n",
        "    if not processed_files:\n",
        "        print(\"Aucune image traitée avec succès\")\n",
        "        return False\n",
        "\n",
        "    print(f\"\\n=== STRUCTURE PRÉSERVÉE ===\")\n",
        "    print(f\"Les images traitées conservent la même organisation que le dossier original\")\n",
        "\n",
        "    if create_zip:\n",
        "        zip_filename = os.path.join(output_base_folder, \"fingerprints_processed_structured.zip\")\n",
        "        zip_success = create_zip_archive(temp_folder, zip_filename)\n",
        "\n",
        "        if zip_success:\n",
        "            zip_size = os.path.getsize(zip_filename) / (1024 * 1024)\n",
        "            print(f\"Taille de l'archive: {zip_size:.2f} MB\")\n",
        "            if cleanup_temp:\n",
        "                shutil.rmtree(temp_folder)\n",
        "                print(\"Dossier temporaire supprimé\")\n",
        "            print(f\"Archive avec structure préservée: {zip_filename}\")\n",
        "            return zip_filename\n",
        "    else:\n",
        "        print(f\"Images traitées avec structure préservée dans: {temp_folder}\")\n",
        "        return temp_folder\n",
        "\n",
        "def main():\n",
        "    \"\"\"\n",
        "    Fonction principale pour exécution dans Colab - Version avec structure préservée\n",
        "    \"\"\"\n",
        "    # Paramètres\n",
        "    output_folder = \"/content/processed_fingerprints_structured\"\n",
        "    target_size = (128, 128)  # Modifiable selon les besoins\n",
        "\n",
        "    # Exécuter le preprocessing avec préservation de structure\n",
        "    result = preprocess_fingerprints_complete(\n",
        "        input_folder=\"/content/drive/MyDrive/DATA\",\n",
        "        output_base_folder=output_folder,\n",
        "        target_size=target_size,\n",
        "        vgg16_compatible=True,\n",
        "        create_zip=True,\n",
        "        cleanup_temp=False  # Garder les dossiers pour vérification\n",
        "    )\n",
        "\n",
        "    if result:\n",
        "        print(f\"\\n✅ Préprocessing terminé avec succès!\")\n",
        "        print(f\"Structure préservée: {result}\")\n",
        "        print(\"\\nCaractéristiques des images:\")\n",
        "        print(\"- Format: PNG RGB (3 canaux)\")\n",
        "        print(\"- Fond: Blanc (après suppression)\")\n",
        "        print(\"- Contraste: Amélioré par canal\")\n",
        "        print(\"- Structure: Identique au dossier original\")\n",
        "        print(\"\\n🗂️  La hiérarchie de dossiers a été conservée intégralement\")\n",
        "    else:\n",
        "        print(\"\\n❌ Échec du préprocessing\")\n",
        "\n",
        "if __name__ == \"__main__\":\n",
        "    main()"
      ]
    }
  ]
}