EP02_03 — 🎨 Quantification des niveaux de gris

2.12.3 EP02_03 🎨 Quantification des niveaux de gris

Dans cette activité, vous devez implémenter la quantification uniforme d’une image, en réduisant le nombre de niveaux d’intensité de gris originaux vers une nouvelle échelle basée sur un nombre de bits plus petit.

Lisez deux entiers L et C, représentant les dimensions de la matrice.
Lisez un entier \(k\) (\(1 \le k \le 8\)), représentant le nouveau nombre de bits de l’image.
Calculez le nombre de niveaux (\(N = 2^k\)) et la taille de l’intervalle (pas).
Pour chaque pixel \(p\), calculez la nouvelle valeur \(p'\) en le mappant vers l’indice du niveau discrétisé correspondant (variant de \(0\) à \(2^k-1\)).
Affichez la matrice résultante avec les mêmes valeurs de dimensions que l’originale.
Consultez Figure 2.14 pour une simulation de cet EP.

📌 Important :

Postérisation : En réduisant drastiquement les niveaux (ex : \(k=2\)), vous remarquerez que les dégradés lisses se transforment en bandes abruptes de couleur en raison de la perte de résolution d’amplitude.
Calcul du pas : L’intervalle entre chaque niveau est défini par \(pas = 256 / 2^k\).
Mappage : La méthode de quantification uniforme par troncature qui mappe le pixel vers l’indice de son niveau discrétisé respectif est donnée par :

\[p' = \left\lfloor \frac{p}{pas} \right\rfloor\]

En termes d’implémentation (comme en Python), cela équivaut à la division entière : p' = p // pas.

2.12.3.1 🧠 Discrétisation de l’amplitude

Alors que le sous-échantillonnage traite de la résolution spatiale, la quantification se concentre sur la précision de la couleur (amplitude). Réduire les bits signifie simplifier l’information chromatique :

Paramètre	Fonction	Effet
Bits (\(k\))	Profondeur de couleur	Définit combien de tons différents l’image peut avoir (\(2^k\)).
Pas	Intervalle de ton	Espacement entre les niveaux de gris autorisés.
Postérisation	Phénomène visuel	Transformation de variations continues en blocs de couleur unie.

2.12.3.2 📋 Tâche (spécification pour VPL)

Entrée :

La première ligne contient L.

La deuxième ligne contient C.

La troisième ligne contient le nombre de bits k.

Les lignes suivantes contiennent les éléments de la matrice \(L \times C\).

Sortie :

La matrice transformée avec les indices des niveaux quantifiés, en conservant la taille originale \(L \times C\).

2.12.3.3 📌 Exemples

Entrée	Sortie	Observation
1 4 2 0 80 170 255	0 1 2 3	Avec \(k=2\), nous avons \(2^2=4\) niveaux discrets disponibles (\(0,1,2,3\)). Le pas est de \(256/4=64\). En appliquant la division entière élément par élément : \(0 // 64 = 0\), \(80 // 64 = 1\), \(170 // 64 = 2\), \(255 // 64 = 3\).
1 5 1 10 50 120 200 250	0 0 0 1 1	Avec \(k=1\), nous avons \(2^1=2\) niveaux (\(0\) et \(1\)). Pas \(=256/2=128\). Les pixels inférieurs à \(128\) donnent \(0\), et les pixels supérieurs ou égaux à \(128\) donnent \(1\).

🎚️ Simulateur EP02_03 : Quantification et profondeur de bits q = round(p · (L − 1) / 255)

Ajustez le nombre de bits de sortie (b) pour observer le mappage des 256 niveaux continus de gris vers L = 2ᵇ niveaux discrets de quantification.

Nombre de bits en sortie (b) 8

        Niveaux discrets (L = 2ᵇ) : 256  | 
        Valeurs affichées : 0 a 255

Original (8 bits → 0…255)

Quantifié (Plage 0…255)

      Bits de sortie = 8 → 256 niveaux (valeurs originales préservées)
    

Figure 2.14: Simulateur EP02_03 : Quantification et Profondeur de Bits (Réduction du Nombre de Niveaux de Gris)

%%writefile EP02_03.py
# Code Python

Overwriting EP02_03.py

TestSuite("EP02_03.py").run()

✔️ EP02_03.cases existe déjà dans casos/
📋 5 cas chargé(s) depuis casos/EP02_03.cases

🔍 Test de Python : EP02_03.py
⚠️ EP02_03.py : fichier vide (moins de 3 lignes). Tests ignorés.