'''
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)
