denoising.py/code/Noise.py

580 lines
12 KiB
Python

# ~*~ encoding: utf-8 ~*~ #
import random
import time
class Noise:
# Applique le bruitage de type "Poivre & Sel" sur la matrice de pixels #
########################################################################
# @param pixelMap Matrice de pixel à traiter (modifier)
# @param seuil pourcentage de l'image à bruiter (50% <=> 1 pixel sur 2 est bruité)
#
def SaltAndPepper_set(self, pixelMap, seuil=10):
seuil = float(seuil);
while seuil >= 1:
seuil /= 100.0
nbPixel = int( len(pixelMap) * len(pixelMap[0]) * seuil )
for bruit in range(0, nbPixel):
x = random.randint(0, len(pixelMap[0]) - 1 )
y = random.randint(0, len(pixelMap) - 1 )
if random.randint(0,1) == 1:
pixelMap[y][x].setRGB(255,255,255);
else:
pixelMap[y][x].setRGB(0,0,0);
# Applique le débruitage de type "Poivre & Sel" sur la matrice de pixels #
##########################################################################
# @param pixelMap Matrice de pixel à traiter (modifier)
# @param seuil Seuil à partir duquel on doit traiter les pixels (écart entre la moyenne des pixels avoisinant et le pixel concerné)
# @param borne 0 = Noir pur et blanc pur sont enlevés; 255 ou + = tout les pixels sont traités
#
def SaltAndPepper_unset(self, pixelMap, seuil=5, borne=5):
width = len( pixelMap[0] )
height = len( pixelMap )
if seuil < 0 or seuil > 255: # si le seuil est incohérent => valeur par défaut (5)
seuil = 5;
if borne < 0 or borne > 255: # si la borne est incohérente => valeur par défaut (5)
borne = 5;
# on parcourt tout les pixels
for y in range(0, len(pixelMap)):
for x in range(0, len(pixelMap[y])):
# on calcule la moyenne des valeurs R G B du pixel courant
pMoy = ( pixelMap[y][x].r + pixelMap[y][x].g + pixelMap[y][x].b ) / 3
# si couleur proche du blanc ou noir (en fonction de la borne)
if pMoy >= 255-borne or pMoy <= borne:
xmin, ymin, xmax, ymax = x, y, x, y; # les bornes ducarré 3x3 autour du pixel
rMoy, gMoy, bMoy, count = 0.0, 0.0, 0.0, 0 # initialisation des variables de moyennes et de total
rInterval, gInterval, bInterval, rgbInterval = 0, 0, 0, 0 # initialisation des variables d'intervalles entre les couleurs
# GESTION DES ANGLES
# ordonnées: borne inférieure
if y-1 > -1:
ymin = y-1
# ordonnées: borne supérieure
if y+1 < height:
ymax = y+1
# abscisses: borne inférieure
if x-1 > -1:
xmin = x-1
# abscisses: borne supérieure
if x+1 < width:
xmax = x+1
# pixels = [ pixelMap[y][xmin], pixelMap[y][xmax], pixelMap[ymin][x], pixelMap[ymax][x] ];
# for p in pixels:
# if p != pixelMap[y][x]:
# rMoy += p.r;
# gMoy += p.g;
# bMoy += p.b;
# count += 1
# on parcourt le carré de 3x3
for j in pixelMap[ymin:ymax]:
for pix in j[xmin:xmax]:
# si le pixel n'est pas le pixel courant (mais ceux autour)
if pix != pixelMap[y][x]:
# calcul de la moyenne autour du pixel
rMoy += pix.r;
gMoy += pix.g;
bMoy += pix.b;
count += 1
# si il y a au moins un pixel autour (normalement tjs mais évite l'erreur div par zéro)
if count > 0:
# on calcule les moyennes somme(xi) / n
rMoy = int( rMoy / count )
gMoy = int( gMoy / count )
bMoy = int( bMoy / count )
# calcul de la différence entre les couleurs du pixel et la moyenne des couleurs des pixels autour
rInterval = abs( pixelMap[y][x].r - rMoy )
gInterval = abs( pixelMap[y][x].g - gMoy )
bInterval = abs( pixelMap[y][x].b - bMoy )
# calcul de la différence en nuance de gris (moyenne des couleurs)
rgbInterval = ( rInterval + gInterval + bInterval ) / 3
# si la couleur est trop "différente" (dépend du seuil) alors on remplace sa couleur par la moyenne des couleurs alentours
if rgbInterval > seuil:
pixelMap[y][x].setRGB(rMoy, gMoy, bMoy);
def AdditiveNoise_set(self, pixelMap, seuil=10):
seuil = float(seuil);
while seuil >= 1:
seuil /= 100.0
nbPixel = int( len(pixelMap) * len(pixelMap[0]) * seuil )
for bruit in range(0, nbPixel ):
x = random.randint(0, len(pixelMap[0]) - 1 )
y = random.randint(0, len(pixelMap) - 1 )
if random.randint(0,1) == 1:
maxColor = max(pixelMap[y][x].r, pixelMap[y][x].g, pixelMap[y][x].b)
randomAdd = random.randint(0, (255-maxColor) / 5 )
else:
minColor = min(pixelMap[y][x].r, pixelMap[y][x].g, pixelMap[y][x].b)
randomAdd = - random.randint(0, minColor / 5 )
pixelMap[y][x].setRGB(
pixelMap[y][x].r + randomAdd,
pixelMap[y][x].g + randomAdd,
pixelMap[y][x].b + randomAdd
);
def AdditiveNoise_unset(self, pixelMap, seuil=10):
width = len( pixelMap[0] )
height = len( pixelMap )
if seuil < 0 or seuil > 255: # si le seuil est incohérent => valeur par défaut (5)
seuil = 5;
# on parcourt tout les pixels
for y in range(0, len(pixelMap)):
for x in range(0, len(pixelMap[y])):
# on calcule la moyenne des valeurs R G B du pixel courant
pMoy = ( pixelMap[y][x].r + pixelMap[y][x].g + pixelMap[y][x].b ) / 3
xmin, ymin, xmax, ymap = x, y, x, y; # les bornes ducarré 3x3 autour du pixel
rMoy, gMoy, bMoy, count = 0.0, 0.0, 0.0, 0 # initialisation des variables de moyennes et de total
rInterval, gInterval, bInterval, rgbInterval = 0, 0, 0, 0 # initialisation des variables d'intervalles entre les couleurs
# GESTION DES ANGLES
# ordonnées: borne inférieure
if y-1 > -1:
ymin = y-1
# ordonnées: borne supérieure
if y+1 < height:
ymax = y+1
# abscisses: borne inférieure
if x-1 > -1:
xmin = x-1
# abscisses: borne supérieure
if x+1 < width:
xmax = x+1
pixels = [ pixelMap[y][xmin], pixelMap[y][xmax], pixelMap[ymin][x], pixelMap[ymax][x] ];
for p in pixels:
if p != pixelMap[y][x]:
rMoy += p.r;
gMoy += p.g;
bMoy += p.b;
count += 1
# si il y a au moins un pixel autour (normalement tjs mais évite l'erreur div par zéro)
if count > 0:
# on calcule les moyennes somme(xi) / n
rMoy = int( rMoy / count )
gMoy = int( gMoy / count )
bMoy = int( bMoy / count )
# calcul de la différence entre les couleurs du pixel et la moyenne des couleurs des pixels autour
rInterval = abs( pixelMap[y][x].r - rMoy )
gInterval = abs( pixelMap[y][x].g - gMoy )
bInterval = abs( pixelMap[y][x].b - bMoy )
# calcul de la différence en nuance de gris (moyenne des couleurs)
rgbInterval = ( rInterval + gInterval + bInterval ) / 3
# si la couleur est trop "différente" (dépend du seuil) alors on remplace sa couleur par la moyenne des couleurs alentours
if rgbInterval > seuil:
pixelMap[y][x].setRGB(rMoy, gMoy, bMoy);
# lissage de l'image
def smooth(self, pixelMap, seuil=5):
width = len( pixelMap[0] )
height = len( pixelMap )
if seuil < 0 or seuil > 255: # si le seuil est incohérent => valeur par défaut (5)
seuil = 5;
# on parcourt tout les pixels
for y in range(0, len(pixelMap)):
for x in range(0, len(pixelMap[y])):
# on calcule la moyenne des valeurs R G B du pixel courant
pMoy = ( pixelMap[y][x].r + pixelMap[y][x].g + pixelMap[y][x].b ) / 3
xmin, ymin, xmax, ymap = x, y, x, y; # les bornes ducarré 3x3 autour du pixel
rMoy, gMoy, bMoy, count = 0.0, 0.0, 0.0, 0 # initialisation des variables de moyennes et de total
rInterval, gInterval, bInterval, rgbInterval = 0, 0, 0, 0 # initialisation des variables d'intervalles entre les couleurs
# GESTION DES ANGLES
# ordonnées: borne inférieure
if y-1 > -1:
ymin = y-1
# ordonnées: borne supérieure
if y+1 < height:
ymax = y+1
# abscisses: borne inférieure
if x-1 > -1:
xmin = x-1
# abscisses: borne supérieure
if x+1 < width:
xmax = x+1
pixels = [ pixelMap[y][xmin], pixelMap[y][xmax], pixelMap[ymin][x], pixelMap[ymax][x] ];
for p in pixels:
if p != pixelMap[y][x]:
rMoy += p.r;
gMoy += p.g;
bMoy += p.b;
count += 1
# si il y a au moins un pixel autour (normalement tjs mais évite l'erreur div par zéro)
if count > 0:
# on calcule les moyennes somme(xi) / n
rMoy = int( rMoy / count )
gMoy = int( gMoy / count )
bMoy = int( bMoy / count )
# calcul de la différence entre les couleurs du pixel et la moyenne des couleurs des pixels autour
rInterval = abs( pixelMap[y][x].r - rMoy )
gInterval = abs( pixelMap[y][x].g - gMoy )
bInterval = abs( pixelMap[y][x].b - bMoy )
# calcul de la différence en nuance de gris (moyenne des couleurs)
rgbInterval = ( rInterval + gInterval + bInterval ) / 3
# si la couleur est trop "différente" (dépend du seuil) alors on remplace sa couleur par la moyenne des couleurs alentours
if rgbInterval > seuil:
pixelMap[y][x].setRGB(rMoy, gMoy, bMoy);
def MultiplicativeNoise_set(self, pixelMap, seuil=10):
pass
def MultiplicativeNoise_unset(self, pixelMap, seuil=5):
pass
def ColorNoise_set(self, pixelMap, seuil=10):
seuil = float(seuil);
while seuil >= 1:
seuil /= 100.0
nbPixel = int( len(pixelMap) * len(pixelMap[0]) * seuil )
for bruit in range(0, nbPixel ):
x = random.randint(0, len(pixelMap[0]) - 1 )
y = random.randint(0, len(pixelMap) - 1 )
pixelMap[y][x].setRGB(
pixelMap[y][x].r + random.randint(0, (255-pixelMap[y][x].r)/4),
pixelMap[y][x].g + random.randint(0, (255-pixelMap[y][x].g)/4),
pixelMap[y][x].b + random.randint(0, (255-pixelMap[y][x].b)/4)
);
def ColorNoise_unset(self, pixelMap, seuil=5):
pass
def Gaussian_set(self, pixelMap, seuil=10):
pass
def Gaussian_unset(self, pixelMap, seuil=5):
pass
# récupère la forme complète autour du pixel donné #
# @param pixel pixel de base
# @param pixelMap matrice de pixels
#
# @return retourne la liste des pixels composant la forme (références)
#
#
#
#
def getShape(self, originalPixel, pixelMap, seuil=10):
width = len( pixelMap[0] )
height = len( pixelMap )
shape = [] # contiendra les pixels de la forme
waiting = [originalPixel] # contient les pixels à traiter
# on continue d'analyser tant qu'il y a des pixels à traiter
while len(waiting) > 0:
pixel = waiting[0]
# on ajoute le pixel à la forme
shape.append( pixel )
xm, xM = pixel.x, pixel.x # valeurs minimales et maximales de x autour du pixel
ym, yM = pixel.y, pixel.y # valeurs minimales et maximales de y autour du pixel
# si on est pas sur le bord gauche
if pixel.x > 0:
xm = pixel.x - 1
# si on est pas sur le bord droit
if pixel.x < width-1:
xM = pixel.x + 1
# si on est pas sur le bord haut
if pixel.y > 0:
ym = pixel.y - 1
# si on est pas sur le bord bas
if pixel.y < height-1:
yM = pixel.y + 1
# on parcourt les pixels alentours
for j in range(ym, yM+1):
for i in range(xm, xM+1):
currentP = pixelMap[j][i]
# si le pixel n'a pas une couleur trop éloignée du pixel central
if abs(pixel.r-currentP.r) <= seuil and abs(pixel.g-currentP.g) <= seuil and abs(pixel.b-currentP.b) <= seuil:
# on ajoute le pixel à la liste d'attente
if not( currentP in shape or currentP in waiting):
waiting.append( currentP )
# on retire le pixel de la liste d'attente
try:
waiting.remove( pixel )
except:
pass
return shape;