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:
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