''' Implementar una función que devuelva el negativo de una imagen. Modo de uso: python3 ej02.py <img1> ''' import numpy as np from PIL import Image from sys import argv import side_by_side im1 = np.asarray(Image.open(argv[1]).convert('L')) L = 255 f = np.vectorize(lambda r : -r + L) im2 = np.uint8(f(im1)) side_by_side.sbys([im1, im2], ['Original', 'Negativo'], argv[2] if len(argv) > 2 else None)
b = 1 K1, K2 = img.shape r = np.zeros(img.shape, dtype=np.float) for k1 in range(K1): for k2 in range(K2): if np.random.uniform(0, 1) < p: r[k1,k2] = 255 if np.random.uniform(0,1) < 0.5 else 0 else: r[k1,k2] = img[k1,k2] return r if __name__ == "__main__": if argv[2] == "gauss": im1 = np.asarray(Image.open(argv[1]).convert('L')) im2 = gaussiano(im1, float(argv[3])) elif argv[2] == "rayleigh": im1 = np.asarray(Image.open(argv[1]).convert('L')) im2 = rayleigh(im1, float(argv[3])) print(im1) print(im2) im3 = ej3.suavizadof(im2) im4 = ej3.realce_de_bordes(im2) side_by_side.sbys([im1, im2, im3, im4], ["Original", "Ruido "+("gaussiano: normal(0,"+argv[3]+")" if argv[2] == "gauss" else "rayleigh: "+argv[3]), "Suavizado", "Unsharp masking"], argv=None if len(argv) <= 4 else argv[4], m=2)
kirsch_n[2, 1] = k[2, 0] kirsch_n[2, 0] = k[1, 0] kirsch_n[1, 0] = k[0, 0] return kirsch_n kirschs = [ kirsch_1, n_kirsch(kirsch_1), n_kirsch(n_kirsch(kirsch_1)), n_kirsch(n_kirsch(n_kirsch(kirsch_1))), n_kirsch(n_kirsch(n_kirsch(n_kirsch(kirsch_1)))), n_kirsch(n_kirsch(n_kirsch(n_kirsch(n_kirsch(kirsch_1))))), n_kirsch(n_kirsch(n_kirsch(n_kirsch(n_kirsch(n_kirsch(kirsch_1)))))), n_kirsch( n_kirsch(n_kirsch(n_kirsch(n_kirsch(n_kirsch(n_kirsch(kirsch_1))))))) ] def op_kirsch(im): r = np.zeros(im.shape, dtype=float) for i in range(8): r = np.maximum(r, convolution.convolution(im, kirschs[i])) return r im1 = np.asarray(Image.open(argv[1]).convert('L')) im2 = op_kirsch(im1) side_by_side.sbys([im1, im2], ["Original", 'Kirsch'], argv=None if len(argv) <= 2 else argv[2])
low_pass_5 = np.ones((5, 5), dtype=np.float) low_pass_5[:, :] = 1. / 25 high_pass_3 = np.ones((3, 3), dtype=np.float) high_pass_3[:, :] /= -9.0 high_pass_3[1, 1] = 8. / 9 high_pass_5 = np.ones((5, 5), dtype=np.float) high_pass_5[:, :] /= -25.0 high_pass_5[2, 2] = 24. / 25 kernels = { "low": { "3": low_pass_3, "5": low_pass_5 }, "high": { "3": high_pass_3, "5": high_pass_5 } } im1 = np.asarray(Image.open(argv[1]).convert('L')) im2 = convolution.convolution(im1, kernels[argv[2]][argv[3]]) print(im1) print(im2) side_by_side.sbys( [im1, im2], ["Original", argv[2] + "-pass filter de " + argv[3] + "x" + argv[3]], argv=None if len(argv) <= 4 else argv[4])
r[i-1, j-1] = U_MAX if im[i+1, j+1] >= U_MIN: r[i+1, j+1] = U_MAX elif -np.pi / 8 >= angulo > -3 * np.pi / 8: if im[i-1, j+1] >= U_MIN: r[i-1, j+1] = U_MAX if im[i+1, j-1] >= U_MIN: r[i+1, j-1] = U_MAX elif angulo > 3 * np.pi / 8 or angulo <= -3 * np.pi / 8: if im[i, j-1] >= U_MIN: r[i, j-1] = U_MAX if im[i, j+1] >= U_MIN: r[i, j+1] = U_MAX idx = r >= U_MAX r[idx] = 1.0 idx = r < U_MAX r[idx] = 0.0 return r im1 = np.asarray(Image.open(argv[1]).convert('L')) im2 = gaussiano(im1) jm, jo = edge_detection(im2, argv[2]) im3 = umbral_por_histeresis(supresion_de_no_maximos(jo, jm), jo) print(jo) print(jm) side_by_side.sbys([im1, im3], ["Original", 'Canny (con '+argv[2]+')'], argv=None if len(argv) <= 3 else argv[3])
''' Implementar una función que aplique un umbral a una imagen, devolviendo una imagen binaria. Modo de uso: python3 ej03.py <img1> <umbral> ''' import numpy as np from PIL import Image from sys import argv import side_by_side im1 = np.asarray(Image.open(argv[1]).convert('L')) umbral = int(argv[2]) f = np.vectorize(lambda r: 255 if r > umbral else 0) side_by_side.sbys([im1, np.uint8(f(im1))], ['Original', 'Umbral (' + argv[2] + ')'], argv[3] if len(argv) > 3 else None)
imx = np.power(imx, 2) imy = np.power(imy, 2) r = convolution.scale(np.power(imx + imy, 0.5)) / np.sqrt(2) convolution.apply_threshold(r, 150) return r im1 = np.asarray(Image.open(argv[1]).convert('L')) im3 = ej4.gaussiano(im1, float(argv[3])) im5 = ej4.salt_and_pepper(im1, float(argv[4])) if argv[2] == "roberts": im2 = border_detection(im1, robertsx, robertsy) im4 = border_detection(im3, robertsx, robertsy) im6 = border_detection(im5, robertsx, robertsy) elif argv[2] == "prewitt": im2 = border_detection(im1, prewittx, prewitty) im4 = border_detection(im3, prewittx, prewitty) im6 = border_detection(im5, prewittx, prewitty) elif argv[2] == "sobel": im2 = border_detection(im1, sobelx, sobely) im4 = border_detection(im3, sobelx, sobely) im6 = border_detection(im5, sobelx, sobely) side_by_side.sbys([im1, im2, im3, im4, im5, im6], [ "Original", "Filtro " + argv[2], "Ruido gaussiano: normal(0," + argv[3] + ")", "Filtro " + argv[2], "Ruido salt & pepper: p = " + argv[4], "Filtro " + argv[2] ], argv=None if len(argv) <= 5 else argv[5], m=3)
if argv[2] == "a": im1 = np.asarray(Image.open(argv[1]).convert('L')) im2 = suavizadof(im1) elif argv[2] == "b": im1 = np.asarray(Image.open(argv[1]).convert('L')) im2 = realce_de_bordes(im1) elif argv[2] == "c": im1 = np.asarray(Image.open(argv[1]).convert('L')) im5 = convolution.convolution(im1, suavizado) THRESHOLD = 200 im2 = convolution.convolution(im5, unsharp) idx = im2[:, :] > THRESHOLD im2[idx] = THRESHOLD im2 = im2.astype(np.uint16) im2 += im1 m = np.amax(im2) im3 = im2 * 255.0 / m im2 = im3.astype(np.uint8) side_by_side.sbys([im1, im5, im2]) exit(0) print(im1) print(im2) side_by_side.sbys( [im1, im2], ["Original", "Suavizado" if argv[2] == "a" else "Unsharp masking"], argv=None if len(argv) <= 3 else argv[3])
''' Fraccionamiento de los planos de bits: hacer un programa que separe una imagen en los 8 planos de bits y mostrarlos cada uno por separado Modo de uso: python3 ej04.py <img1> ''' import numpy as np import side_by_side from PIL import Image from sys import argv im1 = np.asarray(Image.open(argv[1]).convert('L')) ims = [] for s in range(8): f = np.vectorize(lambda r : 255 if r & (1 << s) > 0 else 0) ims.append(np.uint8(f(im1))) side_by_side.sbys([im1]+ims, ['Original']+['Bit '+str(i) for i in range(8)], argv[2] if len(argv) > 2 else None, 3)
''' Compresión del rango dinámico. Modo de uso: python3 ej01-c.py <img1> ''' import numpy as np from PIL import Image from sys import argv import side_by_side from math import log im1 = np.asarray(Image.open(argv[1]).convert('L')) R = 0 L = 256 for p in np.nditer(im1): if p > R: R = p f = np.vectorize(lambda r: (L - 1) * log(1 + r) / log(1 + R)) side_by_side.sbys([im1, f(im1)], ['Original', 'Compresion de rango dinamico'], argv[2] if len(argv) > 2 else None)
if p1 * p2 < 0 and abs(p1 - p2) >= mediana: found = True break r[k1, k2] = 255 if found else 0 return r def ej_c(im1): gaussian = np.ones((5, 5), dtype=np.float) gaussian[:, :] = [[1, 4, 7, 4, 1], [4, 16, 26, 16, 4], [7, 26, 41, 26, 7], [4, 16, 26, 16, 4], [1, 4, 7, 4, 1]] gaussian[:, :] *= 1. / 273 im2 = convolution.convolution(im1, gaussian) return ej_a(im2) im1 = np.asarray(Image.open(argv[1]).convert('L')) fname = "???" filtro = argv[2] if filtro == "a": im2 = ej_a(im1) fname = "Metodo del Laplaciano" elif filtro == "b": im2 = ej_b(im1) fname = "Metodo del Laplaciano con thershold de varianza" elif filtro == "c": im2 = ej_c(im1) fname = "Metodo del Laplaciano del Gaussiano" side_by_side.sbys([im1, im2], ["Original", fname], argv=None if len(argv) <= 3 else argv[3])
''' Producto de una imagen por un escalar. Modo de uso: python3 ej01-b.py <img1> <escalar> ''' from PIL import Image import numpy import side_by_side from sys import argv im1 = numpy.asarray(Image.open(argv[1]).convert('L')) f = float(argv[2]) side_by_side.sbys([im1, f * im1], ['Original', 'Por escalar (' + argv[2] + ')'], argv[3] if len(argv) > 3 else None)
''' Suma, resta y producto de imágenes. Modo de uso: python3 ej01-a.py <img1> <img2> <operacion> ''' from PIL import Image import numpy import side_by_side from sys import argv im1 = numpy.asarray(Image.open(argv[1]).convert('L')) im2 = numpy.asarray(Image.open(argv[2]).convert('L')) if argv[3] == 'suma': side_by_side.sbys([im1, im2, im1 + numpy.minimum(255 - im1, im2)], ['Imagen 1', 'Imagen 2', 'Suma'], argv[4] if len(argv) > 4 else None) if argv[3] == 'resta': side_by_side.sbys([im1, im2, im1- numpy.minimum(im1, im2)], ['Imagen 1', 'Imagen 2', 'Resta'], argv[4] if len(argv) > 4 else None) if argv[3] == 'producto': side_by_side.sbys([im1, im2, im1 * numpy.minimum(255 / im1, im2)], ['Imagen 1', 'Imagen 2', 'Producto'], argv[4] if len(argv) > 4 else None)