294 lines
7.8 KiB
Python
294 lines
7.8 KiB
Python
import umage as um
|
|
from math import sqrt, atan2, sin, cos, pi
|
|
|
|
def greyscale(mat_img):
|
|
gray_img = []
|
|
for ligne in mat_img:
|
|
lig = []
|
|
for r,g,b in ligne:
|
|
v = int(r*0.2125 + g*0.7154 + b*0.0721)
|
|
lig.append((v,)*3)
|
|
gray_img.append(lig)
|
|
return gray_img
|
|
|
|
def convolution(mat_img, mat):
|
|
return_img = []
|
|
for j in range(len(mat_img)):
|
|
ligne = []
|
|
for i in range(len(mat_img[0])):
|
|
val = appliquer_convolution(mat_img, mat, i, j)
|
|
ligne.append((val,)*3)
|
|
return_img.append(ligne)
|
|
return return_img
|
|
|
|
def filtre_sobel(img):
|
|
|
|
def calcul_norme(pixel1, pixel2):
|
|
valeur = pixel1[0]**2 + pixel2[0]**2
|
|
norm = round(sqrt(valeur))
|
|
norm = int(min(norm, 255))
|
|
return norm
|
|
|
|
def application_norme(im_x, im_y):
|
|
result_image = []
|
|
for j in range(len(im_x)):
|
|
ligne = []
|
|
for i in range(len(im_x[0])):
|
|
pixel1 = im_x[j][i]
|
|
pixel2 = im_y[j][i]
|
|
norme = calcul_norme(pixel1, pixel2)
|
|
ligne.append((norme,)*3)
|
|
result_image.append(ligne)
|
|
return result_image
|
|
|
|
if not is_greyscale(img):
|
|
img = greyscale(img)
|
|
|
|
mat_x = [[-1,0,1],[-2,0,2],[-1,0,1]]
|
|
mat_y = [[-1,-2,-1],[0,0,0],[1,2,1]]
|
|
Gx = convolution(img, mat_x)
|
|
Gy = convolution(img, mat_y)
|
|
|
|
filtred_image = application_norme(Gx,Gy)
|
|
return filtred_image
|
|
|
|
|
|
|
|
#########################################################################
|
|
########################Exercices Supplémentaires########################
|
|
#########################################################################
|
|
|
|
def is_greyscale(img):
|
|
_greyscale = True
|
|
for ligne in img:
|
|
for r,g,b in ligne:
|
|
if not (r==g and g==b):
|
|
_greyscale = False
|
|
break
|
|
if not _greyscale:
|
|
break
|
|
return _greyscale
|
|
|
|
def invert(img):
|
|
result_image = []
|
|
for ligne in img:
|
|
result_ligne = []
|
|
for r,g,b in ligne:
|
|
result_ligne.append((255-r, 255-g, 255-b))
|
|
result_image.append(result_ligne)
|
|
return result_image
|
|
|
|
def pixel(img, i, j, default=(0,0,0)):
|
|
#i la colone et j la ligne
|
|
if 0 <= i < len(img[0]) and 0 <= j < len(img):
|
|
return img[j][i]
|
|
else:
|
|
return default
|
|
|
|
def appliquer_convolution(img, mat, i, j):
|
|
somme = 0
|
|
for y in range(len(mat)):
|
|
for x in range(len(mat[0])):
|
|
pixel_i = i - (len(mat[0]) // 2) + x
|
|
pixel_j = j - (len(mat) // 2) + y
|
|
pix = pixel(img, pixel_i, pixel_j)
|
|
somme += pix[0]*mat[y][x]
|
|
return min(max(somme,0), 255)
|
|
|
|
|
|
|
|
######################################################################
|
|
########################Exercices personnelles########################
|
|
######################################################################
|
|
def convolution_gauss(mat_img):
|
|
mat_gauss = [
|
|
[2/159, 4/159, 5/159, 4/159,2/159],
|
|
[4/159, 9/159,12/159, 9/159,4/159],
|
|
[5/159,12/159,15/159,12/159,5/159],
|
|
[4/159, 9/159,12/159, 9/159,4/159],
|
|
[2/159, 4/159, 5/159, 4/159,2/159]
|
|
]
|
|
|
|
return_img = []
|
|
for j in range(len(mat_img)):
|
|
ligne = []
|
|
for i in range(len(mat_img[0])):
|
|
val = reduction_bruit(mat_img, mat_gauss, i, j)
|
|
ligne.append((val,)*3)
|
|
return_img.append(ligne)
|
|
return return_img
|
|
|
|
def reduction_bruit(img, mat, i, j):
|
|
somme = 0
|
|
for y in range(len(mat)):
|
|
for x in range(len(mat[0])):
|
|
pixel_i = i - (len(mat[0]) // 2) + x
|
|
pixel_j = j - (len(mat) // 2) + y
|
|
pix = pixel(img, pixel_i, pixel_j)
|
|
somme += pix[0]*mat[y][x]
|
|
normalise = round(somme)
|
|
return normalise
|
|
|
|
def filtre_canny(img):
|
|
|
|
def norme_gradient(pixel1, pixel2):
|
|
color_x = pixel1[0]
|
|
color_y = pixel2[0]
|
|
|
|
norm = round(sqrt(color_x**2 + color_y**2))
|
|
norm = min(norm, 255)
|
|
|
|
grad = atan2(color_y, color_x)
|
|
return norm, grad
|
|
|
|
def liste_normGrad(im1, im2):
|
|
liste = []
|
|
for j in range(len(im1)):
|
|
ligne = []
|
|
for i in range(len(im1[0])):
|
|
normGrad = norme_gradient(im1[j][i], im2[j][i])
|
|
ligne.append(normGrad)
|
|
liste.append(ligne)
|
|
return liste
|
|
|
|
if not is_greyscale(img):
|
|
img = greyscale(img)
|
|
|
|
mat_x = [[-1,0,1]]
|
|
mat_y = [[1],[0],[-1]]
|
|
|
|
#lissage/suppression des bri
|
|
img_no_bruit = convolution_gauss(img)
|
|
Jx = convolution(img, mat_x)
|
|
Jy = convolution(img, mat_y)
|
|
normGrad = liste_normGrad(Jx, Jy)
|
|
|
|
#Suppresion des non-maximum
|
|
|
|
|
|
#temp
|
|
def norme_gradient(pixel1, pixel2):
|
|
color_x = pixel1[0]
|
|
color_y = pixel2[0]
|
|
|
|
norm = round(sqrt(color_x**2 + color_y**2))
|
|
norm = min(norm, 255)
|
|
|
|
grad = atan2(color_y, color_x)
|
|
return norm, grad
|
|
|
|
#temp
|
|
def liste_normGrad(im1, im2):
|
|
liste = []
|
|
for j in range(len(im1)):
|
|
ligne = []
|
|
for i in range(len(im1[0])):
|
|
normGrad = norme_gradient(im1[j][i], im2[j][i])
|
|
ligne.append(normGrad)
|
|
liste.append(ligne)
|
|
return liste
|
|
|
|
mat_x = [[-1,0,1]]
|
|
mat_y = [[1],[0],[-1]]
|
|
#temp
|
|
#lissage
|
|
img = um.load("imageEngine\\images\\valve.png")
|
|
img = convolution_gauss(img)
|
|
Jx = convolution(img, mat_x)
|
|
Jy = convolution(img, mat_y)
|
|
normGrad = liste_normGrad(Jx, Jy)
|
|
###########
|
|
|
|
|
|
|
|
def find_neighbord_norm(mat, i, j, rad):
|
|
x = 0
|
|
y = 0
|
|
if sin(pi/8) <= abs(sin(rad)):
|
|
y = 1
|
|
if cos(3*pi/8)>abs(cos(rad)):
|
|
x = 1
|
|
|
|
norm_pix1 = -1
|
|
norm_pix2 = -1
|
|
if 0 <= j-y < len(mat):
|
|
if 0 <= i-x < len(mat[0]):
|
|
norm_pix1 = mat[j-y][i-x][0]
|
|
if 0 <= j+y < len(mat):
|
|
if 0 <= i+x < len(mat[0]):
|
|
norm_pix2 = mat[j+y][i+x][0]
|
|
|
|
return norm_pix1, norm_pix2
|
|
|
|
def delete_pixel(mat_img, mat):
|
|
img_to_return = []
|
|
for j in range(len(mat)):
|
|
ligne = []
|
|
for i in range(len(mat[0])):
|
|
rad = mat[j][i][1]
|
|
norms = find_neighbord_norm(mat, i, j, rad)
|
|
if rad < norms[0] or rad < norms[1]:
|
|
ligne.append((0,)*3)
|
|
else:
|
|
ligne.append(mat_img[j][i])
|
|
img_to_return.append(ligne)
|
|
return img_to_return
|
|
|
|
|
|
"""
|
|
def hysteresis(mat_img, mat_norm, Th):
|
|
Tl = Th / 2
|
|
mat_img = yesOrNo(mat_img, Th, Tl)
|
|
result_image = []
|
|
for j in range(len(mat_img)):
|
|
ligne = []
|
|
for i in range(len(mat_img[0])):
|
|
rad = mat_norm[j][i][1]
|
|
color1, color2 = find_neighbord_pixel(mat_img, i, j, rad+(pi/2))
|
|
if color1 == 255 or color2 == 255:
|
|
ligne.append((255,)*3)
|
|
else:
|
|
ligne.append((0,)*3)
|
|
result_image.append(ligne)
|
|
return result_image
|
|
|
|
def find_neighbord_pixel(mat_image, i, j, rad):
|
|
x = 0
|
|
y = 0
|
|
if sin(pi/8) <= abs(sin(rad)):
|
|
y = 1
|
|
if cos(3*pi/8)>abs(cos(rad)):
|
|
x = 1
|
|
|
|
color_pix1 = 0
|
|
color_pix2 = 0
|
|
if 0 <= j-y < len(mat_image):
|
|
if 0 <= i-x < len(mat_image[0]):
|
|
color_pix1 = mat_image[j-y][i-x][0]
|
|
if 0 <= j+y < len(mat_image):
|
|
if 0 <= i+x < len(mat_image[0]):
|
|
color_pix2 = mat_image[j+y][i+x][0]
|
|
|
|
return color_pix1, color_pix2
|
|
|
|
def yesOrNo(mat_img, Th, Tl):
|
|
result_image = []
|
|
for j in range(len(mat_img)):
|
|
ligne = []
|
|
for i in range(len(mat_img[0])):
|
|
pix = mat_img[j][i]
|
|
if Th <= pix[0]:
|
|
ligne.append((255,)*3)
|
|
elif pix[0] < Tl:
|
|
ligne.append((0,)*3)
|
|
else:
|
|
ligne.append(pix)
|
|
result_image.append(ligne)
|
|
return result_image
|
|
|
|
|
|
zt_no_maxima = delete_pixel(img, normGrad)
|
|
zt_hysteresis = hysteresis(zt_no_maxima, normGrad, 200)
|
|
|
|
um.save(zt_hysteresis, "imageEngine\\test\\valve", "png")
|
|
""" |