Filtrage des images – Bac théorique – Section informatique – 2014
Sujet (Algo et programmation - Bac 2014)
Une image représentée en niveaux de gris, est formée par des pixels codés chacun sur huit (8) bits et ayant chacun une valeur comprise entre 0 (noir) et 255 (blanc).
Le filtre médian est une technique de filtrage utilisée dans les traitements d'images bitmap.
L'algorithme du filtre médian consiste à remplacer chaque valeur du pixel de l'image à filtrer par la valeur médiane des pixels voisins. Il s'agit d'un voisinage carré autour du pixel considéré.
Un voisinage est donc assimilable à une matrice canée de taille impair, exemple : voisinage 3x3, 5x5, 7x7, etc. (voir l'exemple ci-après)
N.B.: Lorsqu'un pixel est proche du bord de l'image, certains pixels de son voisinage n'existent pas.
En disposant d'un fichier "Imagelnit.txt" contenant les codes binaires correspondants aux pixels d'une image à filtrer, on se propose d'écrire un programme permettant de remplir une matrice MF, par les valeurs, en décimal, des pixels de l'image filtrée par le principe du filtre médian (voisinage 3x3).
Sachant que :
1. Le fichier "Imagelnit.txt" est constitué comme suit :
- la première ligne, contient la définition de l'image sous la forme HxL où H est le nombre de pixels en hauteur et L le nombre de pixels en largeur.
Exemple : "200x180"
- chacune des HxL lignes suivantes, contient une succession de huit (8) bits représentant le code binaire d'un pixel de l'image.
2- L'image filtrée sera obtenue en procédant comme suit :
- remplir à partir du fichier "Imageinit.txt", une matrice M de H lignes et L colonnes par les conversions en décimal des blocs de huit (8) bits représentant chacun le code d'un pixel.
- appliquer un filtre médian sur chaque élément M[i,j] de la matrice M afin de former une deuxième matrice MF et ce de la manière suivante :
placer les valeurs de la matrice M formant le voisinage 3x3 de M[i,j], dans un tableau T (y compris le pixel lui-même).
N.B. : les éléments du voisinage qui sont en dehors de la matrice M, auront la valeur zéro dans le tableau T.
trier par ordre croissant les éléments du tableau
placer la valeur située au milieu du tableau T trié (valeur médiane), dans la case NIF[i,j] de la matrice MF.
Travail demandé :
1- Analyser ce problème en le décomposant en modules.
2- Analyser chacun des modules envisagés.
Solution Algorithmique
Dans cet algorithme, On va utiliser cinq fonctions et six procédures:
- la fonction saisie()
- la fonction test_octet()
- la fonction saisie_pixel()
- la procédure remplir_fichier_image_init()
- la fonction convsersion_octet_decimal()
- la fonction exposant()
- la procédure remplir_matrice_image()
- la procédure afficher_matrice()
- la procédure remplir_tableau()
- la procédure trier()
- la procédure remplir_matrice_filtree()
Algorithme du programme Principal
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
Algorithme filtrage_images Debut Ecrire('Saisie de la hauteur et largeur de l\'image') # Saisie des dimensions de l'image h <- saisie(2, 401) l <- saisie(2, 401) # Création du fichier image remplir_fichier_image_init(h, l) # Remplissage de la matrice M remplir_matrice_image(m) # Lecture des dimensions depuis le fichier Ouvrir(f_image , "Image_Init.txt", "r") taille <- Lire_ligne(f_image) hauteur <- Valeur(taille[0:taille.find('x')]) largeur <- Valeur(taille[taille.find('x')+1:len(taille)]) Fermer(f_image) Ecrire('*** Contenu de la matrice M ***') afficher_matrice(m, hauteur, largeur) # Application du filtre médian remplir_matrice_filtree(mf, m, hauteur, largeur) Ecrire('*** Contenu de la matrice filtree MF ***') afficher_matrice(mf, hauteur, largeur) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| h | entier |
| l | entier |
| m | matrice |
| m | entier |
| f_image | fichier |
| taille | chaîne |
| hauteur | entier |
| largeur | entier |
| mf | matrice |
La fonction saisie
Le rôle de cette fonction est de permettre à l’utilisateur de saisir un entier n compris strictement entre deux bornes inf et sup.
1- La fonction saisie(inf, sup) demande à l’utilisateur d’entrer un entier n.
2- Elle vérifie que n appartient à l’intervalle ouvert ] inf , sup [ (c’est-à-dire inf < n < sup). 3- Tant que la valeur saisie n’est pas valide (n ≤ inf ou n ≥ sup), la fonction redemande la saisie. 4- Une fois une valeur correcte entrée, la fonction retourne n.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
Fonction saisie(inf:entier, sup:entier):entier # Première saisie de n Ecrire('donner n tel que ', inf , '< n < ' , sup, ': ')) Lire(n) # Tant que n n’appartient pas à l’intervalle ]inf , sup[ # on redemande la saisie Tant que (n <= inf) ou (n >= sup) faire Ecrire('donner n tel que ', inf , '< n < ' , sup, ': ')) Lire(n) Fin tant que # Retourne la valeur valide retourner n Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| n | entier |
La fonction test_octet
Cette fonction sert à vérifier si une chaîne de caractères représente un octet valide, c’est-à-dire un nombre binaire composé de 8 bits, contenant uniquement les caractères 0 et 1.
1- Vérification de la longueur
La fonction commence par tester si la chaîne octet contient exactement 8 caractères.
Si ce n’est pas le cas → elle retourne False.
2- Vérification du contenu
Elle parcourt la chaîne caractère par caractère à l’aide d’une boucle while.
Tant que l’indice i est inférieur à len(octet)-1 et que le caractère courant est '0' ou '1', on continue.
Après la boucle, elle vérifie aussi que le dernier caractère est bien '0' ou '1'.
3- Valeur retournée
Vrai : si la chaîne contient 8 caractères et tous sont 0 ou 1
Faux : sinon
|
1 2 3 4 5 6 7 8 9 10 11 12 |
Fonction test_octet(octet:chaine):booleen # Vérifier que la longueur est égale à 8 Si long(octet) = 8 alors i <- 0 # Vérifier que tous les caractères sont '0' ou '1' Tant que (i < long(octet)-1) et (octet[i] dans ['0', '1']) faire i <- i + 1 Fin tant que retourner (octet[i] dans ['0', '1']) Sinon retourner Faux Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
La fonction saisie_pixel()
Cette fonction permet de saisir un pixel représenté sous forme binaire, en s’assurant que la valeur entrée par l’utilisateur est un octet valide (8 bits composés uniquement de 0 et de 1).
1- Saisie de l’octet
La fonction demande à l’utilisateur de saisir un pixel sous forme d’un octet (chaîne de caractères).
2- Vérification de la validité
Elle utilise la fonction test_octet(octet) pour vérifier si la saisie correspond bien à un octet valide.
Tant que la valeur saisie n’est pas valide, la fonction redemande la saisie.
3- Retour du résultat
Une fois un octet correct saisi, la fonction retourne cet octet valide.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction saisie_pixel():chaine Ecrire('donner un pixel sous forme d un octet: ') Lire(octet) #Tant que l'octet n'est pas valide, on redemande la saisie Tant que Non(verif_octet(octet)) faire Ecrire('donner un pixel sous forme d un octet: ') Lire(atome) Fin tant que retourner octet Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| octet | chaîne |
La procédure remplir_fichier_image_init
Cette procédure permet de créer et remplir le fichier Image_Init.txt avec les pixels d’une image, saisis par l’utilisateur, ligne par ligne, sous forme d’octets binaires valides.
1- Affichage d’un message
Informe l’utilisateur qu’il est en train de remplir le fichier Image_Init.txt.
2- Ouverture du fichier
Le fichier Image_Init.txt est ouvert en mode écriture ("w").
S’il existe déjà, son contenu est écrasé.
3- Écriture des dimensions de l’image
Les dimensions de l’image sont écrites sur la première ligne du fichier sous la forme : hxl
où : h : nombre de lignes (hauteur) et l : nombre de colonnes (largeur)
4- Saisie et écriture des pixels
Deux boucles imbriquées parcourent l’image : i pour les lignes et j pour les colonnes
À chaque position (i, j) : un pixel est saisi via la fonction saisie_pixel() (qui garantit un octet valide) et le pixel est écrit dans le fichier.
Après chaque ligne de pixels, un retour à la ligne est ajouté.
5- Fermeture du fichier
Le fichier est fermé pour sauvegarder correctement les données.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
Procedure remplir_fichier_image_init(h:entier, l:entier): Ecrire('*** Remplir le fichier Image_Init.txt ***') # Ouverture du fichier en écriture Ouvrir(f , "Image_Init.txt", "w") # Écriture des dimensions de l'image Ecrire(f, Convch(h) + 'x' + Convch(l) + '\n') # Remplissage des pixels ligne par ligne Pour i de 0 à h-1 faire Pour j de 0 à l-1 faire pixel <- saisie_pixel() Ecrire(f , pixel) Fin pour Ecrire(f , '\n') Fin pour # Fermeture du fichier Fermer(f) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f | fichier |
| i | entier |
| j | entier |
| pixel | chaîne |
La fonction exposant
Cette fonction permet de calculer et retourner la valeur de (2 puissance e), sans utiliser de fonction mathématique prédéfinie.
1- Initialisation
La variable valeur est initialisée à 1
2- Calcul par multiplication répétée
Une boucle for s’exécute e fois. À chaque itération, la valeur est multipliée par 2.
3- Retour du résultat
Après la fin de la boucle, la fonction retourne la valeur calculée.
|
1 2 3 4 5 6 7 |
Fonction exposant(e:entier):entier valeur <- 1 Pour i de 0 à e-1 faire valeur <- valeur * 2 Fin pour retuorner valeur Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| valeur | entier |
La fonction convsersion_octet_decimal
Cette fonction permet de convertir un octet binaire (chaîne de 8 bits) en son équivalent en nombre décimal.
1- Initialisation
La variable decimal est initialisée à 0. Elle servira à accumuler la valeur décimale finale.
2- Parcours des bits
La boucle parcourt les positions de l’octet. On lit les bits de droite à gauche (du bit de poids faible au bit de poids fort).
Pour chaque bit :
si le bit vaut '1', on ajoute à decimal la valeur de 2 exposant i (la puissance de 2 est calculée par la fonction exposant(i)).
3- Retour du résultat
La fonction retourne la valeur décimale correspondant à l’octet binaire.
|
1 2 3 4 5 6 7 8 9 10 |
Fonction convsersion_octet_decimal(octet:chaine):entier decimal <- 0 Pour i de 0 à long(octet)-1 faire # Si le bit vaut 1, on ajoute la puissance correspondante Si octet[long(octet)-i-1]='1' alors decimal <- decimal + exposant(i) Fin si Fin pour retourner decimal Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| decimal | entier |
| i | entier |
La procédure remplir_matrice_image
Cette procédure permet de charger une image enregistrée dans le fichier Image_Init.txt et de remplir la matrice M avec les valeurs décimales des pixels.
1- Ouverture du fichier
Le fichier Image_Init.txt est ouvert en mode lecture.
2- Lecture des dimensions
La première ligne du fichier (contenant les dimensions de l’image sous la forme hxl) est lue et stockée dans taille.
Cette information n’est pas utilisée directement dans la procédure, mais permet d’ignorer cette ligne.
3- Lecture des pixels
Toutes les lignes suivantes sont lues et stockées dans la liste image.
Chaque ligne correspond à une ligne de pixels binaires.
4- Remplissage de la matrice
i représente l’indice de la ligne dans la matrice.
Pour chaque ligne de pixels : on enlève le caractère de fin de ligne et on regroupe les bits 8 par 8 pour former un octet.
À chaque octet formé : il est converti de binaire en décimal grâce à convsersion_octet_decimal et la valeur obtenue est stockée dans la matrice m[i][j],
5- Fermeture du fichier
Le fichier est fermé après la lecture complète.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
Procedure remplir_matrice_image(m:matrice) Ouvrir(f_image , "Image_Init.txt", "r") # Lecture de la première ligne (dimensions) taille <- Lire_ligne(f_image) # Lecture des lignes de pixels image <- Lire_lignes(f_image) i <- 0 Pour pixels dans image faire j <- 0 pixels <- pixels.strip('\n') octet <- '' # Regroupement des bits par octets Pour k de 0 à long(pixels)-1 faire octet <- octet + pixels[k] Si long(octet) = 8 alors # Conversion binaire → décimal m[i][j] <- convsersion_octet_decimal(octet) j <- j + 1 octet <- '' Fin si i = i + 1 Fin pour Fermer(f_image) Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| f_image | fichier |
| taille | chaîne |
| i | entier |
| j | entier |
| pixels | chaîne |
| octet | chaîne |
La procédure afficher_matrice
Cette procédure permet d’afficher le contenu d’une matrice m à l’écran, ligne par ligne, selon ses dimensions.
1- Parcours des lignes
La boucle externe parcourt les lignes de la matrice de 0 à hauteur - 1.
2- Parcours des colonnes
La boucle interne parcourt les colonnes de 0 à largeur - 1.
3- Affichage des éléments
Chaque élément m[i][j] est affiché suivi d’un espace.
L’instruction end=' ' permet d’afficher les valeurs sur la même ligne.
4- Retour à la ligne
Après l’affichage de chaque ligne de la matrice, un saut de ligne est effectué avec Ecrire().
|
1 2 3 4 5 6 7 8 |
Procedure afficher_matrice(m:matrice, hauteur:entier, largeur:entier) Pour i de 0 à hauteur-1 faire Pour j de 0 à largeur-1 faire Ecrire(m[i][j],' ') Fin pour Ecrire() Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
La procédure remplir_tableau
Cette procédure permet de remplir le tableau t avec les 9 pixels voisins du pixel situé à la position (i, j) dans la matrice m, y compris le pixel central.
La matrice m représente une image (ou une matrice de pixels).
Le pixel central est m[i][j].
Les pixels voisins correspondent au voisinage 3×3 autour de ce pixel.
|
1 2 3 4 5 6 7 8 9 10 11 |
Procedure remplir_tableau(m:matrice, i:entier, j:entier, t:tableau) t[0] <- m[i-1][j-1] t[1] <- m[i-1][j] t[2] <- m[i][j-1] t[3] <- m[i-1][j+1] t[4] <- m[i][j] t[5] <- m[i][j+1] t[6] <- m[i+1][j-1] t[7] <- m[i+1][j] t[8] <- m[i+1][j+1] Fin |
La procédure trier
Le rôle de cette procédure trier est de trier le tableau t par ordre croissant en utilisant l’algorithme du tri par sélection.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
Procédure trier(t:tableau) Pour i de 0 à 7 faire min <- i Pour j de i à 8 faire Si t[min] > t[j] alors min <- j Fin si Fin pour Si min != i alors temp <- t[i] t[i] <- t[min] t[min] <- temp Fin si Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
| min | entier |
| temp | entier |
La procédure remplir_matrice_filtree
Le rôle de cette procédure remplir_matrice_filtree est de remplir la matrice mf en appliquant un filtre médian à partir de la matrice m (traitement d’image).
Explication du fonctionnement :
m : matrice originale (image d’origine).
mf : matrice filtrée (image résultante).
hauteur, largeur : dimensions de l’image.
t : tableau temporaire contenant les valeurs des pixels voisins (3×3 → 9 valeurs).
Étapes principales
1- Parcours de tous les pixels de l’image
Chaque pixel (i, j) est traité séparément.
2- Remplissage du tableau t
Cette procédure place dans t les 9 valeurs des pixels voisins du pixel (i, j) (fenêtre 3×3).
3- Tri des valeurs
Les 9 valeurs sont triées par ordre croissant.
4- Sélection de la médiane
L’élément central du tableau trié (t[4]) correspond à la médiane.
Cette valeur devient le nouveau pixel dans la matrice filtrée.
|
1 2 3 4 5 6 7 8 9 10 |
Procédure remplir_matrice_filtree(mf:matrice, m:matrice, hauteur:entier, largeur:entier) Pour i de 0 à hauteur-1 faire Pour j de 0 à largeur-1 faire remplir_tableau(m, i, j, t) trier(t) # Le pixel central devient la médiane mf[i][j] <- t[4] Fin pour Fin pour Fin |
Déclaration des objets
| Objet | Type / Nature |
|---|---|
| i | entier |
| j | entier |
| t | tableau |
Solution en Python
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 |
from numpy import * # -------------------------------------------------- # Définition des dimensions maximales de la matrice # -------------------------------------------------- lignes = 50 # Nombre maximal de lignes de l'image colonnes = 50 # Nombre maximal de colonnes de l'image # Création de la matrice M (image initiale) # Initialisée par des entiers m = array([[int()] * colonnes] * lignes) # Création de la matrice MF (image filtrée) mf = array([[int()] * colonnes] * lignes) # Tableau temporaire utilisé pour stocker les 9 pixels voisins t = array([int()] * 100) # -------------------------------------------------- # Fonction qui permet de saisir un entier n # strictement compris entre inf et sup # -------------------------------------------------- def saisie(inf, sup): # Saisie d'un entier par l'utilisateur n = int(input('donner n tel que ' + str(inf) + '< n < ' + str(sup) + ': ')) # Vérification de l'appartenance à l'intervalle ]inf, sup[ while (n <= inf) or (n >= sup): n = int(input('donner n tel que ' + str(inf) + '< n < ' + str(sup) + ': ')) # Retour de la valeur valide return n # -------------------------------------------------- # Fonction qui vérifie si une chaîne représente # un octet valide (8 bits composés uniquement de 0 et 1) # -------------------------------------------------- def test_octet(octet): # Vérifier que la longueur est égale à 8 if len(octet) == 8: i = 0 # Vérifier que tous les caractères sont '0' ou '1' while (i < len(octet)-1) and (octet[i] in ['0', '1']): i = i + 1 return (octet[i] in ['0', '1']) else: return False # -------------------------------------------------- # Fonction qui permet la saisie d'un pixel # sous forme d'un octet valide # -------------------------------------------------- def saisie_pixel(): # Saisie d'un octet octet = input('donner un pixel sous forme d un octet: ') # Tant que l'octet n'est pas valide, on redemande la saisie while not(test_octet(octet)): octet = input('donner un pixel sous forme d un octet: ') # Retour de l'octet valide return octet # -------------------------------------------------- # Procédure qui remplit le fichier Image_Init.txt # par les pixels de l'image # -------------------------------------------------- def remplir_fichier_image_init(h, l): print('*** Remplir le fichier Image_Init.txt ***') # Ouverture du fichier en écriture f = open("Image_Init.txt", "w") # Écriture des dimensions de l'image f.write(str(h) + 'x' + str(l) + '\n') # Remplissage des pixels ligne par ligne for i in range(h): for j in range(l): pixel = saisie_pixel() f.write(pixel) f.write('\n') # Fermeture du fichier f.close() # -------------------------------------------------- # Fonction qui calcule 2 puissance e # -------------------------------------------------- def exposant(e): valeur = 1 for i in range(e): valeur = valeur * 2 return valeur # -------------------------------------------------- # Fonction qui convertit un octet binaire # en nombre décimal # -------------------------------------------------- def convsersion_octet_decimal(octet): decimal = 0 for i in range(len(octet)): # Si le bit vaut 1, on ajoute la puissance correspondante if octet[len(octet) - i - 1] == '1': decimal = decimal + exposant(i) return decimal # -------------------------------------------------- # Procédure qui remplit la matrice M # à partir du fichier Image_Init.txt # -------------------------------------------------- def remplir_matrice_image(m): f_image = open("Image_Init.txt", "r") # Lecture de la première ligne (dimensions) taille = f_image.readline() # Lecture des lignes de pixels image = f_image.readlines() i = 0 for pixels in image: j = 0 pixels = pixels.strip('\n') octet = '' # Regroupement des bits par octets for k in range(len(pixels)): octet = octet + pixels[k] if len(octet) == 8: # Conversion binaire → décimal m[i][j] = convsersion_octet_decimal(octet) j = j + 1 octet = '' i = i + 1 f_image.close() # -------------------------------------------------- # Procédure qui affiche une matrice # -------------------------------------------------- def afficher_matrice(m, hauteur, largeur): for i in range(hauteur): for j in range(largeur): print(m[i][j], end=' ') print() # -------------------------------------------------- # Procédure qui remplit le tableau t # par les 9 pixels voisins du pixel (i, j) # -------------------------------------------------- def remplir_tableau(m, i, j, t): t[0] = m[i-1][j-1] t[1] = m[i-1][j] t[2] = m[i][j-1] t[3] = m[i-1][j+1] t[4] = m[i][j] t[5] = m[i][j+1] t[6] = m[i+1][j-1] t[7] = m[i+1][j] t[8] = m[i+1][j+1] # -------------------------------------------------- # Procédure de tri du tableau t (tri par sélection) # -------------------------------------------------- def trier(t): for i in range(8): min = i for j in range(i, 9): if t[min] > t[j]: min = j if min != i: temp = t[i] t[i] = t[min] t[min] = temp # -------------------------------------------------- # Procédure qui applique un filtre médian # -------------------------------------------------- def remplir_matrice_filtree(mf, m, hauteur, largeur): for i in range(hauteur): for j in range(largeur): remplir_tableau(m, i, j, t) trier(t) # Le pixel central devient la médiane mf[i][j] = t[4] # ================== Programme principal ================== print('Saisie de la hauteur et largeur de l\'image') # Saisie des dimensions de l'image h = saisie(2, 401) l = saisie(2, 401) # Création du fichier image remplir_fichier_image_init(h, l) # Remplissage de la matrice M remplir_matrice_image(m) # Lecture des dimensions depuis le fichier f_image = open("Image_Init.txt", "r") taille = f_image.readline() hauteur = int(taille[0:taille.find('x')]) largeur = int(taille[taille.find('x')+1:len(taille)]) f_image.close() print('*** Contenu de la matrice M ***') afficher_matrice(m, hauteur, largeur) # Application du filtre médian remplir_matrice_filtree(mf, m, hauteur, largeur) print('*** Contenu de la matrice filtree MF ***') afficher_matrice(mf, hauteur, largeur) |
Exécution du programme
0 commentaire
laisser un commentaire
Passion de robotique
Tutoriels récents
Atelier robotique
Tutoriels populaires
Construction des robots
Tutoriels plus commentés
Bras robotique
Categories
Maison intelligente
