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:
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 = 0
if imagem.get_tipo() == 'P3':
imagem = self.get_processamentos().get_escala_cinza().processar(
imagem)
# Cores pre-definidas
cores = [[[45, 165, 195], [149, 248, 63], [209, 206, 54],
[95, 15, 191]],
[[127, 219, 218], [173, 228, 152], [237, 230, 130],
[254, 191, 99]],
[[0, 0, 92], [106, 9, 125], [192, 96, 161], [255, 220, 180]],
[[235, 236, 241], [32, 106, 93], [31, 64, 104], [27, 28, 37]]]
random.shuffle(cores)
# Colorir imagem
pixels_coloridos = []
for i in range(len(cores)):
pixels_coloridos.append(
self._processar_parcial(imagem, cores[i], params == 1
and i >= len(cores) / 2))
# Montar imagem
meia_largura = imagem.get_largura()
meia_altura = imagem.get_altura()
largura = imagem.get_largura() * 2
altura = imagem.get_altura() * 2
novos_pixels = []
for i in range(largura):
for j in range(altura):
indice_pixels_coloridos = int(j / meia_largura) * 2 + int(
i / meia_largura)
x = i % meia_largura
y = j % meia_altura
indice = x * meia_largura + y
novos_pixels.append(
pixels_coloridos[indice_pixels_coloridos][indice])
imagem.set_largura(largura)
imagem.set_altura(altura)
imagem.set_tipo('P3')
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(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
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:
maxval = imagem.get_maxval()
imagem.set_pixels(processar_independente(imagem, lambda p: maxval - p))
return imagem
def processar(self, imagem: Imagem, params=None) -> Imagem:
maxval = imagem.get_maxval()
imagem.set_pixels(
processar_independente(
imagem, lambda p: int((math.log(1 + (p / maxval))) * maxval)))
return imagem