denoising.py/code/utility/Filter.py

205 lines
4.7 KiB
Python
Raw Normal View History

# ~*~ encoding: utf-8 ~*~ #
import random
import time
2015-09-29 11:55:50 +00:00
import sys
sys.path.append(sys.path[0]+'/..')
from BMPFile import RGBPixel
2015-09-29 11:55:50 +00:00
class Filter:
2015-10-02 12:10:13 +00:00
# Applique un filtre moyen à l'image de base vers l'image de sortie #
#####################################################################
# @param pixelMap Matrice de pixel à traiter (modifier)
# @param seuil Ecart entre le pixel et ses alentours à partir duquel on applique le lissage
#
2015-10-02 12:10:13 +00:00
#
# Celà revient à effectuer un produit de convolution avec le noyau de conv. suivant :
#
# 1 1 1
2015-10-05 16:07:59 +00:00
# 1 1 1
2015-10-02 12:10:13 +00:00
# 1 1 1
#
def averageFilter(self, pixelMap):
return self.Convolution(pixelMap, kernel=[
[1, 1, 1],
2015-10-05 16:07:59 +00:00
[1, 1, 1],
2015-10-02 12:10:13 +00:00
[1, 1, 1]
] );
2015-09-29 11:55:50 +00:00
2015-10-02 12:10:13 +00:00
# Applique un filtre de Roberts à l'image de base vers l'image de sortie #
##########################################################################
# @param pixelMap Matrice de pixel à traiter (modifier)
#
#
# Celà revient à effectuer un produit de convolution avec le noyau de conv. suivant :
#
# 1 0
# 0 -1
#
def Roberts(self, pixelMap):
return self.Convolution(pixelMap, kernel=[
[1, 0],
[0, -1]
] );
# Applique un filtre de Laplace à l'image de base vers l'image de sortie #
##########################################################################
# @param pixelMap Matrice de pixel à traiter (modifier)
#
#
# Celà revient à effectuer un produit de convolution avec le noyau de conv. suivant :
#
# -1 -1 -1
# -1 8 -1
# -1 -1 -1
#
def Laplace(self, pixelMap):
return self.Convolution(pixelMap, kernel=[
[-1, -1, -1],
[-1, 8, -1],
[-1, -1, -1]
] );
2015-10-02 12:10:13 +00:00
# Applique un filtre de Sobel à l'image de base vers l'image de sortie #
########################################################################
# @param pixelMap Matrice de pixel à traiter (modifier)
#
#
# Celà revient à effectuer un produit de convolution avec le noyau de conv. suivant :
#
# -1 0 1
# -2 0 2
# -1 0 1
#
def Sobel(self, pixelMap):
return self.Convolution(pixelMap, kernel=[
[-1, 0, 1],
[-2, 0, 2],
[-1, 0, 1]
] );
2015-10-05 16:07:59 +00:00
# Applique un filtre passe-haut à l'image de base vers l'image de sortie #
##########################################################################
# @param pixelMap Matrice de pixel à traiter (modifier)
#
#
# Celà revient à effectuer un produit de convolution avec le noyau de conv. suivant :
#
# -1 0 1
# -2 0 2
# -1 0 1
#
def HighPass(self, pixelMap):
return self.Convolution(pixelMap, kernel=[
[ 0, -1, 0],
[-1, 5, -1],
[ 0, -1, 0]
] );
# applique le filtre de "convolution" sur l'image #
###################################################
# @param pixelMap la matrice de pixels à modifier
#
# @history
# applique le filtre
def Convolution(self, pixelMap, kernel=None):
width = len( pixelMap[0] )
height = len( pixelMap )
if kernel == None:
2015-09-29 11:55:50 +00:00
print "no kernel given!"
exit()
# nb total résultant du kernel des valeurs positives
kernelFactor = 0;
for b in kernel:
for a in b:
if a > 0:
kernelFactor += a;
kMidWidth = len( kernel[0] ) // 2
kMidHeight = len( kernel ) // 2
# map de résultat (filtrée)
2015-10-02 12:10:13 +00:00
convolvedMap = []
# on parcourt tout les pixels
for y in range(0, height):
# on rajoute une ligne à la map filtrée
convolvedMap.append( [] )
for x in range(0, width):
pixel = pixelMap[y][x];
# on définit la matrice de même taille que le kernel mais correspondant aux pixels superposés
pixelM = [];
for b in range(-kMidHeight, 1+kMidHeight):
pixelM.append( [] );
for a in range(-kMidWidth, 1+kMidWidth):
# on met les valeurs entre 0 et longueur ou largeur pour pas récupérer les valeurs de l'autre côté (lissage bizarre)
ruledX = 0 if x+a<0 else width-1 if x+a>=width else x+a;
ruledY = 0 if y+b<0 else height-1 if y+b>=height else y+b;
2015-10-02 12:10:13 +00:00
# if x+a<0 or x+a>=width or y+b<0 or y+b>=height: # si pixel dépasse de l'image, on l'ajoute pas
# on ajoute le pixel courant
pixelM[len(pixelM)-1].append( pixelMap[ruledY][ruledX] );
r,g,b = 0,0,0
2015-10-02 12:10:13 +00:00
# on effectue la convolution
for linePixelM, lineKernel in zip(pixelM, kernel):
for pix, fact in zip(linePixelM, lineKernel):
# pour chacun des filtres
2015-10-02 12:10:13 +00:00
r += pix.r * fact
g += pix.g * fact
b += pix.b * fact
r = int(r/kernelFactor) % 256
g = int(g/kernelFactor) % 256
b = int(b/kernelFactor) % 256
# définition des couleurs sur la map filtrée
convolvedMap[y].append( RGBPixel(
r = r,
g = g,
b = b,
x = x,
y = y,
bpp = pixel.bpp
) )
2015-10-02 12:10:13 +00:00
return convolvedMap