TP : analyse d'images

Table of contents

• Filtrage d'images
  • Préambule
  • Exercice 4
  • Exercice 5

Filtrage d'images

Dans cette partie du TP, les fonctions OpenCV utilisées/utilisables sont les suivantes :

cv2.blur(src, ksize[, dst[, anchor[, borderType]]]) -> dst
cv2.GaussianBlur(src, ksize, sigmaX[, dst[, sigmaY[, borderType]]]) -> dst
cv2.medianBlur(src, ksize[, dst]) -> dst
cv2.filter2D(src, ddepth, kernel[, dst[, anchor[, delta[, borderType]]]]) -> dst
cv2.getStructuringElement(shape, ksize[, anchor]) -> retval

Préambule

Afin de pouvoir tester les fonctions de filtrages, voici quelques fonctions permettant d'ajouter du "bruit" à une image selon différentes méthodes.

def bruitGaussien(image,moyenne,variance):
    if len(image.shape)==3:
        row,col,ch= image.shape
        sigma = variance**0.5
        gauss = np.random.normal(moyenne,sigma,(row,col,ch))
        gauss = gauss.reshape(row,col,ch)
        noisy = image + gauss
        return noisy.astype(np.uint8)
    else:
        row,col= image.shape
        sigma = variance**0.5
        gauss = np.random.normal(moyenne,sigma,(row,col))
        print(np.min(gauss),np.max(gauss))
        gauss = gauss.reshape(row,col)
        noisy = image + gauss
        return noisy.astype(np.uint8)

def bruitPoivreEtSel(image,prob):
    row= image.shape[0]
    col = image.shape[1]
    out = image.copy()
    if len(image.shape) == 2:
        black = 0
        white = 255            
    else:
        colorspace = image.shape[2]
        if colorspace == 3:  # RGB
            black = np.array([0, 0, 0], dtype='uint8')
            white = np.array([255, 255, 255], dtype='uint8')
        else:  # RGBA
            black = np.array([0, 0, 0, 255], dtype='uint8')
            white = np.array([255, 255, 255, 255], dtype='uint8')
    probs = np.random.random(out.shape[:2])
    # Pepper mode
    out[probs < (prob / 2)] = black
    # Salt mode
    out[probs > 1 - (prob / 2)] = white
    return out.astype(np.uint8)

def bruitPoisson(image):
    vals = len(np.unique(image))
    vals = 2 ** np.ceil(np.log2(vals))
    noisy = np.random.poisson(image * vals) / float(vals)
    return noisy.astype(np.uint8)

def bruitSpeckle(image):
    gauss = np.random.normal(0,1,image.size)
    if len(image.shape)==3:
        row,col,ch = image.shape
        gauss = gauss.reshape(row,col,ch).astype(np.uint8)
        noisy = image + image * gauss
        return noisy.astype(np.uint8)
    else:
        row,col = image.shape
        gauss = gauss.reshape(row,col).astype(np.uint8)
        noisy = image + image * gauss
        return noisy.astype(np.uint8)

Exercice 4

Ecrire un programme permettant de comparer le floutage d'une image en utilisant les 3 méthodes : cv2.blur, cv2.GaussianBlur et cv2.medianBlur.

Vous devrez, dans un premier temps, ajouter du bruit à une image préalablement chargée.

Votre programme devra permettre de modifier la taille du noyau de filtrage grace à un slider (la même taille de noyau sera utilisée pour les 3 filtres).

Pour comparer les résultats, utiliser la fonction mse donnée en fin du tp d'introduction.

Exercice 5

Les 3 fonctions utilisées précédemment permettent d'utiliser des filtres usuels de taille carrée (ou rectangulaire).

Il est possible d'appliquer des filtres de taille et de forme non usuelles. Pour cela, on utilise la fonction cv2.getStructuringElement. Cette fonction va renvoyer une matrice 2d dont les éléments inclus dans la forme définie par le paramètre shape sont initialisés à 1 alors que les autres seront à 0.

Le noyau de filtrage ainsi obtenu peut être appliqué à une image en utilisant la fonction cv2.filter2D.

Utiliser ces fonction pour appliquer un filtre moyen en croix de taille 5x5 sur une image. Comparer les résultats avec ceux obtenus par un filtrage moyen de même taille en utilisant la fonction cv2.blur.