Appliquer un filtre moyenneur (flou)

Le flou est partout dans le traitement d'image. Quand ton téléphone applique un effet "portrait" qui rend l'arrière-plan flou, c'est un filtre de ce type (en plus sophistiqué). Quand un algorithme de détection d'objets pré-traite une image pour éliminer le bruit d'un capteur bas de gamme, il commence souvent par un flou. En imagerie médicale, le flou permet de lisser les artefacts des scanners avant l'analyse.

Imagine que tu regardes un paysage à travers une vitre embuée. Chaque point que tu vois est un mélange de ce point et de ses voisins. C'est exactement ce que fait le filtre moyenneur : chaque pixel est remplacé par la moyenne de ses voisins.

En pratique, tu utiliserais cv2.blur(image, (taille, taille)) pour un flou moyenneur, ou cv2.GaussianBlur() pour un flou gaussien plus naturel. Ici on l'implémente nous-mêmes avec NumPy pour comprendre le principe de la convolution, qui est la base de toutes les opérations de filtrage en vision par ordinateur et aussi au coeur des réseaux de neurones convolutifs (CNN).

Le principe : tu prends un petit carré (le noyau ou kernel) de taille n x n autour de chaque pixel, tu calcules la moyenne des valeurs dans ce carré, et tu remplaces le pixel par cette moyenne. Un kernel 3x3 prend les 8 voisins + le pixel central (9 valeurs). Un kernel 5x5 prend 25 valeurs.

Pour simplifier, on ne traite pas les bords de l'image (les pixels trop près du bord n'ont pas assez de voisins). Les bords sont laissés à 0.

Écris une fonction flou_moyenneur(image_gris, taille_kernel) qui prend une image en niveaux de gris (2D) et la taille du kernel (un entier impair : 3, 5, 7...). La fonction renvoie une nouvelle image floutée de même taille, où les bords sont laissés à 0.

Exemple :
img = np.array([[10, 10, 10, 10, 10],
[10, 50, 50, 50, 10],
[10, 50, 90, 50, 10],
[10, 50, 50, 50, 10],
[10, 10, 10, 10, 10]], dtype=np.uint8)
result = flou_moyenneur(img, 3)
Le pixel central (2,2) qui valait 90 vaut maintenant environ 42 (moyenne de ses 9 voisins).

Ce que tu devrais voir sur ta machine : une photo floutée, les détails fins disparaissent. Plus le kernel est grand, plus le flou est fort.

Tests (5/5)

Forme conservee

import numpy as np
img = np.zeros((10, 10), dtype=np.uint8)
result = flou_moyenneur(img, 3)
assert result.shape == (10, 10), f'La forme doit etre conservee, obtenue {result.shape}'

Image uniforme reste uniforme au centre

import numpy as np
img = np.full((7, 7), 100, dtype=np.uint8)
result = flou_moyenneur(img, 3)
assert result[3, 3] == 100, f'Le centre d une image uniforme doit rester a 100, obtenu {result[3, 3]}'

Bords a zero

import numpy as np
img = np.full((5, 5), 200, dtype=np.uint8)
result = flou_moyenneur(img, 3)
assert result[0, 0] == 0, 'Le coin doit etre a 0 (bord non traite)'

Flou reduit les extremes

import numpy as np
img = np.zeros((5, 5), dtype=np.uint8)
img[2, 2] = 255
result = flou_moyenneur(img, 3)
assert result[2, 2] < 255, f'Le pixel central doit etre reduit par le flou, obtenu {result[2, 2]}'
assert result[2, 2] > 0, 'Le pixel central ne doit pas etre a 0'

Kernel 5x5

import numpy as np
img = np.full((9, 9), 50, dtype=np.uint8)
result = flou_moyenneur(img, 5)
assert result[4, 4] == 50, 'Le centre d une image uniforme doit rester identique avec kernel 5x5'
assert result[0, 0] == 0, 'Les bords doivent etre a 0 avec kernel 5x5'

Indices (3 disponibles)

Solution officielle

import numpy as np

def flou_moyenneur(image_gris, taille_kernel):
    h, w = image_gris.shape
    pad = taille_kernel // 2
    résultat = np.zeros_like(image_gris)
    for i in range(pad, h - pad):
        for j in range(pad, w - pad):
            voisins = image_gris[i - pad:i + pad + 1, j - pad:j + pad + 1]
            résultat[i, j] = int(np.mean(voisins))
    return résultat

← Seuillage d'une image (thresholding) Detecter les contours avec le … →

solution.py

Bravo!

Appliquer un filtre moyenneur (flou)

Tests (5/5)

Indices (3 disponibles)

Solution officielle