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 = 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(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_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_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 imagem.get_tipo() == 'P2':
return imagem
return converter_pgm(imagem)