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:
imagem_original = imagem
imagem_dilatacao = self.get_processamentos().get_dilatacao().processar(
imagem.clonar(), params)
pixels_original = imagem_original.get_pixels()
pixels_dilatacao = imagem_dilatacao.get_pixels()
for i in range(len(pixels_original)):
pixels_original[i] = (pixels_original[i] - pixels_dilatacao[i]) % 2
return imagem
def open_file(self):
file_name, _ = QtWidgets.QFileDialog.getOpenFileName(
self,
caption="Abrir Imagem",
directory=QtCore.QDir.currentPath(),
filter='Imagens(*.ppm; *.pgm; *.pbm)',
initialFilter='Imagens(*.ppm; *.pgm; *.pbm)')
if file_name != '':
print('Abrindo imagem...')
self.texto_progresso.setText('Abrindo imagem...')
self.barra_progresso.setValue(0)
self.imagem_original = Imagem()
sucesso = self.imagem_original.carregar(file_name)
if not sucesso:
self.exibir_erro(self.imagem_alterada.get_erro())
self.barra_progresso.setValue(100)
self.barra_status.showMessage(
"Não foi possível abrir a imagem.", 5000)
print('Abrir imagem -> FALHA')
return
print('Abrir imagem -> 50%')
self.barra_progresso.setValue(50)
self.imagem_alterada = self.imagem_original.clonar()
print('Abrir imagem -> 80%')
self.barra_progresso.setValue(80)
pixmap = QtGui.QPixmap(file_name)
pixmap = pixmap.scaled(250, 250, QtCore.Qt.KeepAspectRatio)
self.imagem_1.setPixmap(pixmap)
self.imagem_2.setPixmap(pixmap)
print('Abrir imagem -> 100%')
self.barra_progresso.setValue(100)
self.barra_status.showMessage("Imagem aberta com sucesso.", 5000)
print('Abrir imagem -> COMPLETO')
self.atualizar_menus()
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:
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:
maxval = imagem.get_maxval()
imagem.set_pixels(processar_independente(imagem, lambda p: maxval - p))
return imagem
def processar_clone(self, imagem: Imagem, params=None) -> Imagem:
clone = imagem.clonar()
self.processar(clone, params)
return clone
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:
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:
maxval = imagem.get_maxval()
imagem.set_pixels(
processar_independente(
imagem, lambda p: int((math.log(1 + (p / maxval))) * maxval)))
return imagem
class MyWindow(QMainWindow):
# Constantes
LARGURA = 640
ALTURA = 480
CAMINHO_TEMP = '.temp'
def __init__(self):
super(MyWindow, self).__init__()
# Definir propriedades
self.layout = None
self.barra_progresso = None
self.barra_status = None
self.imagem_1 = None
self.imagem_2 = None
self.texto_progresso = None
self.menu_salvar_arquivo = None
self.menu_sobre_imagem = None
self.menu_resetar_imagem = None
self.menus_processamentos = []
self.processamentos = Processamentos()
self.imagem_original = None
self.imagem_alterada = None
# Montar interface
self.setup_main_window()
self.init_ui()
self.atualizar_menus()
def setup_main_window(self):
# Definir formato
self.setMinimumSize(QSize(MyWindow.LARGURA, MyWindow.ALTURA))
self.setWindowTitle("Processamento Digital de Imagens - IFTM")
# Definir layout
widget = QWidget(self)
self.setCentralWidget(widget)
self.layout = QGridLayout()
widget.setLayout(self.layout)
def init_ui(self):
# Criar a barra de menu
barra_menu = self.menuBar()
# Criar o menu arquivo
menu_arquivo = barra_menu.addMenu("&Arquivo")
opcao_abrir = menu_arquivo.addAction("A&brir")
opcao_abrir.triggered.connect(self.open_file)
opcao_abrir.setShortcut("Ctrl+A")
self.menu_salvar_arquivo = menu_arquivo.addAction("S&alvar como")
self.menu_salvar_arquivo.triggered.connect(self.save_file)
self.menu_salvar_arquivo.setShortcut("Ctrl+S")
menu_arquivo.addSeparator()
opcao_fechar = menu_arquivo.addAction("F&echar")
opcao_fechar.triggered.connect(self.close)
opcao_fechar.setShortcut("Ctrl+X")
# Criar o menu transformacoes
menu_transformacoes = barra_menu.addMenu("&Transformações")
self.menu_resetar_imagem = menu_transformacoes.addAction(
"Resetar Imagem")
self.menu_resetar_imagem.triggered.connect(self.resetar_imagem)
menu_transformacoes.addSeparator()
for processamento in self.processamentos.get_todos():
if processamento.get_default_params() is not None:
menu = menu_transformacoes.addMenu(processamento.get_nome())
# Definir sub menus
for (param_name,
param_value) in processamento.get_default_params():
submenu = menu.addAction(param_name)
# Definir a acao em outro escopo para manter o valor da variavel processamento
submenu.triggered.connect(
self._get_processamento_acao(processamento,
param_value))
else:
menu = menu_transformacoes.addAction(processamento.get_nome())
# Definir a acao em outro escopo para manter o valor da variavel processamento
menu.triggered.connect(
self._get_processamento_acao(processamento))
# Adicionar tooltip, se presente
if len(processamento.get_descricao()) > 0:
menu.setToolTip(processamento.get_descricao())
# Guardar na lista de acoes de processamentos
menu.setEnabled(False)
self.menus_processamentos.append((processamento, menu))
# Criar o menu sobre
menu_sobre = barra_menu.addMenu("&Sobre")
opcao_sobre = menu_sobre.addAction("Sobre o Aplicativo")
opcao_sobre.triggered.connect(self.exibir_sobre_aplicativo)
self.menu_sobre_imagem = menu_sobre.addAction("Sobre a Imagem")
self.menu_sobre_imagem.triggered.connect(self.exibir_sobre_imagem)
# Criar barra de status
self.barra_status = self.statusBar()
self.barra_status.showMessage("Seja bem-vindo", 3000)
# Criando a barra de progresso
self.barra_progresso = QProgressBar(self)
self.barra_progresso.setAlignment(QtCore.Qt.AlignCenter)
self.barra_progresso.move(0, 100)
# Criar os widgets (Label, Text, Image)
# Criando um QLabel para texto
texto = QLabel("Trabalho Final", self)
texto.adjustSize()
texto.setAlignment(QtCore.Qt.AlignCenter)
# Criando um QLabel para informar que há uma barra de progresso
self.texto_progresso = QLabel("Carregando...")
# Criando uma imagem(QLabel)
self.imagem_1 = QLabel(self)
self.imagem_1.setAlignment(QtCore.Qt.AlignCenter)
self.imagem_2 = QLabel(self)
self.imagem_2.setAlignment(QtCore.Qt.AlignCenter)
# Organizando os widgets dentro do GridLayout
self.layout.addWidget(texto, 0, 0, 1, 4)
self.layout.addWidget(self.imagem_1, 1, 0, 2, 2)
self.layout.addWidget(self.imagem_2, 1, 2, 2, 2)
self.layout.addWidget(self.texto_progresso, 2, 0)
self.layout.addWidget(self.barra_progresso, 3, 0, 1, 4)
# Definindo a largura das linhas
self.layout.setRowStretch(0, 0)
self.layout.setRowStretch(1, 1)
self.layout.setRowStretch(2, 0)
self.layout.setRowStretch(3, 1)
def exibir_sobre_aplicativo(self):
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setWindowTitle("Sobre")
msg.setText(SOBRE_NOME_AUTOR)
msg.setInformativeText(
"Localização: %s\nData: %s\nLink Apresentação: %s" %
(SOBRE_CIDADE, SOBRE_DATA, SOBRE_LINK_VIDEO))
msg.exec_() # exibir a caixa de mensagem/diálogo
def exibir_sobre_imagem(self):
imagem = self.imagem_original
comentarios = ''
if len(imagem.get_comentario()) > 0:
comentarios = '\nComentario nos detalhes.'
msg = QMessageBox()
msg.setIcon(QMessageBox.Information)
msg.setWindowTitle("Sobre")
msg.setText(imagem.get_caminho())
msg.setInformativeText(
"Tipo: %s\nTamanho: %dx%d\nPrecisão: %d%s" %
(imagem.get_tipo(), imagem.get_largura(), imagem.get_altura(),
imagem.get_maxval(), comentarios))
if len(comentarios) > 0:
msg.setDetailedText(imagem.get_comentario())
msg.exec_() # exibir a caixa de mensagem/diálogo
def exibir_erro(self, texto: str):
msg = QMessageBox()
msg.setIcon(QMessageBox.Abort)
msg.setWindowTitle("Erro")
msg.setText(texto)
msg.exec_() # exibir a caixa de mensagem/diálogo
def open_file(self):
file_name, _ = QtWidgets.QFileDialog.getOpenFileName(
self,
caption="Abrir Imagem",
directory=QtCore.QDir.currentPath(),
filter='Imagens(*.ppm; *.pgm; *.pbm)',
initialFilter='Imagens(*.ppm; *.pgm; *.pbm)')
if file_name != '':
print('Abrindo imagem...')
self.texto_progresso.setText('Abrindo imagem...')
self.barra_progresso.setValue(0)
self.imagem_original = Imagem()
sucesso = self.imagem_original.carregar(file_name)
if not sucesso:
self.exibir_erro(self.imagem_alterada.get_erro())
self.barra_progresso.setValue(100)
self.barra_status.showMessage(
"Não foi possível abrir a imagem.", 5000)
print('Abrir imagem -> FALHA')
return
print('Abrir imagem -> 50%')
self.barra_progresso.setValue(50)
self.imagem_alterada = self.imagem_original.clonar()
print('Abrir imagem -> 80%')
self.barra_progresso.setValue(80)
pixmap = QtGui.QPixmap(file_name)
pixmap = pixmap.scaled(250, 250, QtCore.Qt.KeepAspectRatio)
self.imagem_1.setPixmap(pixmap)
self.imagem_2.setPixmap(pixmap)
print('Abrir imagem -> 100%')
self.barra_progresso.setValue(100)
self.barra_status.showMessage("Imagem aberta com sucesso.", 5000)
print('Abrir imagem -> COMPLETO')
self.atualizar_menus()
def save_file(self):
imagem = self.imagem_alterada
file_name, _ = QtWidgets.QFileDialog.getSaveFileName(
self,
caption="Salvar Imagem",
directory=QtCore.QDir.currentPath(),
filter='%s (%s)' % (imagem.get_tipo(), imagem.get_extensao()))
if file_name != '':
print('Salvando imagem...')
self.texto_progresso.setText('Salvando imagem...')
self.barra_progresso.setValue(0)
sucesso = self.imagem_alterada.salvar(file_name)
if not sucesso:
self.exibir_erro(self.imagem_alterada.get_erro())
self.barra_progresso.setValue(100)
self.barra_status.showMessage(
"Não foi possível salvar a imagem.", 5000)
print('Salvar imagem -> FALHA')
return
print('Salvar imagem -> 100%')
self.barra_progresso.setValue(100)
self.barra_status.showMessage("Imagem salva com sucesso.", 5000)
print('Salvar imagem -> COMPLETO')
def resetar_imagem(self):
print('Resetando imagem...')
self.texto_progresso.setText('Resetando imagem...')
self.barra_progresso.setValue(0)
self.imagem_alterada = self.imagem_original.clonar()
print('Resetar imagem -> 80%')
self.barra_progresso.setValue(80)
pixmap = QtGui.QPixmap(self.imagem_alterada.get_caminho())
pixmap = pixmap.scaled(250, 250, QtCore.Qt.KeepAspectRatio)
self.imagem_2.setPixmap(pixmap)
print('Resetar imagem -> 100%')
self.barra_progresso.setValue(100)
self.barra_status.showMessage("Imagem resetada.", 5000)
self.atualizar_menus()
print('Resetar imagem -> COMPLETO')
def transform_me(self, processamento: Processamento, param_value: any):
print('Processando:', processamento.get_nome(), '(', param_value,
')...')
self.texto_progresso.setText('Processando imagem...')
self.barra_progresso.setValue(0)
self.imagem_alterada = processamento.processar(self.imagem_alterada,
param_value)
print('Processamento -> 40%')
self.barra_progresso.setValue(40)
self.imagem_alterada.salvar(MyWindow.CAMINHO_TEMP)
time.sleep(.1)
print('Processamento -> 80%')
self.barra_progresso.setValue(80)
pixmap = QtGui.QPixmap(self.imagem_alterada.get_caminho())
pixmap = pixmap.scaled(250, 250, QtCore.Qt.KeepAspectRatio)
self.imagem_2.setPixmap(pixmap)
print('Processamento -> 100%')
self.barra_progresso.setValue(100)
self.barra_status.showMessage(
processamento.get_nome() + " finalizado.", 5000)
self.atualizar_menus()
print('Processamento -> COMPLETO')
def atualizar_menus(self):
if self.imagem_alterada is None:
tem_imagem = False
imagem_binaria = False
imagem_nao_binaria = False
else:
tem_imagem = True
imagem_binaria = self.imagem_alterada.get_binario()
imagem_nao_binaria = not imagem_binaria
self.menu_salvar_arquivo.setEnabled(tem_imagem)
self.menu_sobre_imagem.setEnabled(tem_imagem)
self.menu_resetar_imagem.setEnabled(tem_imagem)
for (processamento, menu) in self.menus_processamentos:
ativo = (imagem_binaria and processamento.get_permitir_binarias()
) or (imagem_nao_binaria
and processamento.get_permitir_nao_binarias())
menu.setEnabled(ativo)
def _get_processamento_acao(self,
processamento: Processamento,
param_value: any = None):
return lambda: self.transform_me(processamento, param_value)
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)
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