def processar(self, imagem: Imagem, params=None) -> Imagem:
if params is None:
params = 64
kernelx = [[-1, 0, 1], [2, 0, -2], [1, 0, -1]]
kernelx = np.asarray(kernelx)
kernely = [[1, 2, 1], [0, 0, 0], [-1, -2, -1]]
kernely = np.asarray(kernely)
ks = int((len(kernelx) - 1) / 2)
largura = imagem.get_largura()
altura = imagem.get_altura()
novos_pixels = []
if imagem.get_tipo() == 'P3':
pixels = np.reshape(imagem.get_pixels(), (altura, largura, 3))
for x in range(ks, largura - ks):
for y in range(ks, altura - ks):
sum = [0, 0, 0]
for k in range(3):
sumx = 0
sumy = 0
for ki in range(len(kernelx)):
for kj in range(len(kernelx[1])):
sumx = sumx + (
pixels[x - ks + ki][y - ks + kj][k] *
kernelx[ki][kj])
sumy = sumy + (
pixels[x - ks + ki][y - ks + kj][k] *
kernely[ki][kj])
sumxy = math.sqrt((sumx**2) + (sumy**2))
sum[k] = max(sumxy, params)
sum[k] = int(sum[k]) if sum[k] != params else 0
novos_pixels.append(sum)
else:
pixels = np.reshape(imagem.get_pixels(), (altura, largura))
for x in range(ks, largura - ks):
for y in range(ks, altura - ks):
sumx = 0
sumy = 0
for ki in range(len(kernelx)):
for kj in range(len(kernelx[1])):
sumx = sumx + (pixels[x - ks + ki][y - ks + kj] *
kernelx[ki][kj])
sumy = sumy + (pixels[x - ks + ki][y - ks + kj] *
kernely[ki][kj])
sumxy = math.sqrt((sumx**2) + (sumy**2))
sum = max(sumxy, params)
sum = int(sum) if sum != params else 0
novos_pixels.append(sum)
imagem.set_pixels(np.array(novos_pixels))
imagem.set_largura(largura - 2 * ks)
imagem.set_altura(altura - 2 * ks)
return imagem
def processar(self, imagem: Imagem, params=None) -> Imagem:
if params is None:
params = 90
indice = int((params % 360) / 90)
pixels = imagem.get_pixels()
novos_pixels = []
if indice % 2 == 1:
aux = imagem.get_largura()
imagem.set_largura(imagem.get_altura())
imagem.set_altura(aux)
largura = imagem.get_largura()
altura = imagem.get_altura()
if indice == 1: # 90
for j in range(0, altura):
for i in range(largura - 1, -1, -1):
novos_pixels.append(pixels[imagem.get_pixel_index(i, j)])
elif indice == 2: # 180
for i in range(largura - 1, -1, -1):
for j in range(altura - 1, -1, -1):
novos_pixels.append(pixels[imagem.get_pixel_index(i, j)])
elif indice == 3: # 270
for j in range(altura - 1, -1, -1):
for i in range(0, largura):
novos_pixels.append(pixels[imagem.get_pixel_index(i, j)])
imagem.set_pixels(np.array(novos_pixels))
return imagem
def processar(self, imagem: Imagem, params=None) -> Imagem:
estruturante = self.get_estruturante(params)
pixel = int((len(estruturante) - 1) / 2)
pixels = imagem.get_pixels()
pixels = np.reshape(pixels,
(imagem.get_altura(), imagem.get_largura()))
novos_pixels = pixels.copy()
for i in range(pixel, imagem.get_altura() - pixel):
for j in range(pixel, imagem.get_largura() - pixel):
for x in range(len(estruturante)):
for y in range(len(estruturante[1])):
if pixels[i][j] == 0 and estruturante[x][y] == 1:
novos_pixels[i - pixel + x][j - pixel + y] = 0
novos_pixels = np.reshape(novos_pixels, len(imagem.get_pixels()))
imagem.set_pixels(novos_pixels)
return imagem
def processar(self, imagem: Imagem, params=None) -> Imagem:
elemento = self.get_elemento(params)
es = int((len(elemento) - 1) / 2)
pixels = imagem.get_pixels()
pixels = np.reshape(pixels,
(imagem.get_altura(), imagem.get_largura()))
novos_pixels = pixels.copy()
for px in range(es, imagem.get_altura() - es):
for py in range(es, imagem.get_largura() - es):
if pixels[px][py] == 1:
for ex in range(len(elemento)):
for ey in range(len(elemento[1])):
if elemento[ex][ey] == 1:
novos_pixels[px - es + ex][py - es + ey] = 1
novos_pixels = np.reshape(novos_pixels, len(imagem.get_pixels()))
imagem.set_pixels(novos_pixels)
return imagem
def processar_independente(imagem: Imagem, func, params=None):
"""
:param func: function(pixel: int or int[], params?)
"""
if not callable(func):
raise Exception()
if imagem.get_tipo() == 'P3':
if params is not None:
return np.array(
[[func(p[0], params),
func(p[1], params),
func(p[2], params)] for p in imagem.get_pixels()])
else:
return np.array([[func(p[0]), func(p[1]),
func(p[2])] for p in imagem.get_pixels()])
else:
if params is not None:
return np.array([func(p, params) for p in imagem.get_pixels()])
else:
return np.array([func(p) for p in imagem.get_pixels()])
def processar(self, imagem: Imagem, params=None) -> Imagem:
kernel = self.get_kernel(params)
ks = int((len(kernel) - 1) / 2)
largura = imagem.get_largura()
altura = imagem.get_altura()
novos_pixels = []
if imagem.get_tipo() == 'P3':
pixels = np.reshape(imagem.get_pixels(), (altura, largura, 3))
for x in range(ks, altura - ks):
for y in range(ks, largura - ks):
sum = [0, 0, 0]
for k in range(3):
for ki in range(len(kernel)):
for kj in range(len(kernel[1])):
sum[k] = sum[k] + (
pixels[x - ks + ki][y - ks + kj][k] *
kernel[ki][kj])
sum[k] = int(sum[k])
novos_pixels.append(np.array(sum))
else:
pixels = np.reshape(imagem.get_pixels(), (altura, largura))
for x in range(ks, altura - ks):
for y in range(ks, largura - ks):
sum = 0
for ki in range(len(kernel)):
for kj in range(len(kernel[1])):
sum = sum + (pixels[x - ks + ki][y - ks + kj] *
kernel[ki][kj])
sum = int(sum)
novos_pixels.append(sum)
imagem.set_pixels(np.array(novos_pixels))
imagem.set_largura(largura - (2 * ks))
imagem.set_altura(altura - (2 * ks))
return imagem
def processar(self, imagem: Imagem, params=None) -> Imagem:
if params is None:
params = int(255 * .50)
if imagem.get_tipo() == 'P3':
imagem = self.get_processamentos().get_escala_cinza().processar(
imagem)
pixels = imagem.get_pixels()
for i in range(len(pixels)):
p = pixels[i]
if p > params:
pixels[i] = 1
else:
pixels[i] = 0
return converter_pbm(imagem)
def processar_unico(imagem: Imagem, indice: int, func, params=None):
"""
:param func: function(pixel: int or int[], params?)
"""
if not callable(func):
raise Exception()
p = imagem.get_pixels()[indice]
if imagem.get_tipo() == 'P3':
if params is not None:
return [func(p[0], params), func(p[1], params), func(p[2], params)]
else:
return [func(p[0]), func(p[1]), func(p[2])]
else:
if params is not None:
return func(p, params)
else:
return func(p)
def processar(self, imagem: Imagem, params=None) -> Imagem:
if imagem.get_tipo() != 'P3':
imagem = converter_ppm(imagem)
# Azul
if params == 'b':
indice = 2
# Verde
elif params == 'g':
indice = 1
# Vermelho
else:
indice = 0
pixels = imagem.get_pixels()
for i in range(len(pixels)):
p = pixels[i]
novo_pixel = np.zeros(len(p))
novo_pixel[indice] = p[indice]
pixels[i] = novo_pixel
return imagem
def processar(self, imagem: Imagem, params=None) -> Imagem:
if params is None:
params = 0
indice = params
pixels = imagem.get_pixels()
novos_pixels = []
largura = imagem.get_largura()
altura = imagem.get_altura()
if indice == 0: # Vertical
for i in range(largura - 1, -1, -1):
for j in range(0, altura):
novos_pixels.append(pixels[imagem.get_pixel_index(i, j)])
else: # Horizontal
for i in range(0, largura):
for j in range(altura - 1, -1, -1):
novos_pixels.append(pixels[imagem.get_pixel_index(i, j)])
imagem.set_pixels(np.array(novos_pixels))
return imagem