def houghLinhas(image, threshold):
#################
#Entradas
# - Imagem
# - Limiar
#################
img = np.copy(image)
#Detecção das bordas usando detector Canny
edges = cv2.Canny(image, 50, 200, apertureSize=3)
#Aplicação da transformada
# - Saída do detector de bordas
# - Parametro rô (rho)
# - Parametro teta (theta)
# - Limiar
lines = cv2.HoughLines(edges, 1, np.pi / 180, threshold)
#Desenhando linhas encontradas
for i in range(0, len(lines)):
rho = lines[i][0][0]
theta = lines[i][0][1]
a = math.cos(theta)
b = math.sin(theta)
x0 = a * rho
y0 = b * rho
pt1 = (int(x0 + 1000 * (-b)), int(y0 + 1000 * (a)))
pt2 = (int(x0 - 1000 * (-b)), int(y0 - 1000 * (a)))
cv2.line(image, pt1, pt2, (0, 0, 255), 3, cv2.LINE_AA)
#visualizacao do resultado
lab1.viewImages([img, image], ['Imagem original', 'Transformada de Hough'])
return saveChanges(img, image)
def descontinuidade(image):
#######################
#Entradas
# - Imagem
# - Limiar
#######################
limiar = int(input("Informe o valor (positivo) do limiar: "))
#converte a imagem para a escala de cinza se for colorida
if len(image.shape) > 2:
image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
#aplica o Filtro Laplaciano
image_laplaciano = cv2.Laplacian(image_gray, cv2.CV_64F, 3)
#converte para unsigned int de 8 bits
image_laplaciano = np.uint8(np.absolute(image_laplaciano))
#realiza a limiarização
lim, img_limiar = cv2.threshold(image_laplaciano, limiar, 255,
cv2.THRESH_BINARY)
lab1.viewImages([image, image_laplaciano, img_limiar],
['Imagem original', 'Filtro Laplaciano', 'Limiarização'])
return saveChanges(image, image_laplaciano, img_limiar)
def prewitt(image):
# converte a imagem para cinza, se ela ja não for
if len(image.shape) > 2:
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
else:
gray = image
# cria as máscaras
kernelx = np.array([[1, 1, 1], [0, 0, 0], [-1, -1, -1]], dtype=np.float32)
kernely = np.array([[-1, 0, 1], [-1, 0, 1], [-1, 0, 1]], dtype=np.float32)
# aplica o filtro prewitt nas direcoes x e y
grad_x = cv2.filter2D(gray, -1, kernelx)
grad_y = cv2.filter2D(gray, -1, kernely)
# o resultado de cada mascara do filtro possui valores float
# pega o valor absoluto dos pixels resultantes do gradiente na direcao x e y
abs_grad_x = cv2.convertScaleAbs(grad_x)
abs_grad_y = cv2.convertScaleAbs(grad_y)
# cv2.addWeighted(src1, alpha, src2, beta, gamma) -> src1 * alpha + src2 * beta + gamma
# faz a soma dos grdientes x e y
grad = cv2.addWeighted(
grad_x, 0.5, grad_y, 0.5, 0
) # gradiente com valores float. Os valores são deslocados para serem 8b
# exibe as imagens
lab1.viewImages([image, grad],
['Imagem original', 'Prewitt valores absolutos'])
return saveChanges(image, grad)
def sobel(img):
#recebe a dimensao da mascara
kernel = 0
print()
while(kernel is not 3 and kernel is not 5 and kernel is not 7):
kernel = int(input('Tamanho do filtro? (3 ou 5 ou 7, apenas) : '))
if kernel is not 3 and kernel is not 5 and kernel is not 7 :
print('ERRO: O tamanho do filtro deve ser 3, 5 ou 7!')
# converte a imagem para cinza, se ela ja não for
if len(img.shape) > 2:
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
else:
gray = img
# aplica o filtro sobel nas direcoes x e y
grad_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=kernel)
grad_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=kernel)
# o resultado de cada mascara do filtro possui valores float
# pega o valor absoluto dos pixels resultantes do gradiente na direcao x e y
abs_grad_x = cv2.convertScaleAbs(grad_x)
abs_grad_y = cv2.convertScaleAbs(grad_y)
# cv2.addWeighted(src1, alpha, src2, beta, gamma) -> src1 * alpha + src2 * beta + gamma
# faz a soma dos grdientes x e y
grad = cv2.addWeighted(grad_x, 0.5, grad_y, 0.5, 0) # gradiente com valores float. Os valores são deslocados para serem 8b
grad_trunc = cv2.addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0) # gradiente com valores absolutos
# exibe as imagens
lab1.viewImages([img, grad_trunc, grad], ['Imagem original', 'Sobel valores absolutos', 'Sobel valores deslocados'])
return saveChanges(img,grad_trunc)
def negative(image):
'''
Input: imagem BGR
Output: None
'''
if len(image.shape) > 2:
#separa as componentes RGB
B, G, R = cv2.split(image)
#inverte cada componente
B_neg = 255 - B
G_neg = 255 - G
R_neg = 255 - R
#merge das componentes
im_neg = cv2.merge([B_neg, G_neg, R_neg])
# converte para escala de cinza
im_neg_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
# inverte
im_neg_gray = 255 - im_neg_gray
# exibe as imagens
lab1.viewImages([im_neg, im_neg_gray],
['Imagem Negativa', 'Imagem negativa Escala de Cinza'])
else:
im_neg = 255 - image # inverte
lab1.viewImage(im_neg, 'imagem negativa') # exibe a imagem
return saveChanges(image, im_neg)
def houghCirculos(image, minRadius, maxRadius):
#################
#Entradas
# - Imagem
# - Raio minimo
# - Raio maximo
#################
output = np.copy(image)
#escala de cinza
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
#suavizacao para reduzir ruido e
#diminuir deteccao de ciruculos falsos
gray = cv2.medianBlur(gray, 5)
rows = gray.shape[0]
#Aplicação da transformada
# - Imagem em tonsde cinza
# - Metodo de deteccao
# -
# - Distancia minima entre os centros
# - Limiar superior
# - Limiar para detecacao de centro
# - Raio minimo
# - Raio maximo
circles = cv2.HoughCircles(gray,
cv2.HOUGH_GRADIENT,
1,
rows / 8,
param1=100,
param2=30,
minRadius=minRadius,
maxRadius=maxRadius)
#Desenhando circulos encontrados
if circles is not None:
circles = np.uint16(np.around(circles))
for i in circles[0, :]:
center = (i[0], i[1])
# circle center
cv2.circle(output, center, 1, (0, 100, 100), 3)
# circle outline
radius = i[2]
cv2.circle(output, center, radius, (255, 0, 255), 3)
#visualizacao do resultado
lab1.viewImages([image, output],
['Imagem original', 'Transformada de Hough'])
return saveChanges(image, output)
def kmeans(image, gray, K):
#######################
#Entradas
# - Imagem
# - Aplicar tons de cinza (sim ou não)
# - Numero de clusters
#######################
#Conversao para tons de cinza
if gray == True:
image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
Z = image.reshape((-1, 3))
#Conversao para float32
Z = np.float32(Z)
#Definicao do criterio
# - Tupla com:
# - tipo
# . - TERM_CRITERIA_EPS
# . pare se a precisão for atingida.
# .
# . - TERM_CRITERIA_MAX_ITER
# . pare se número maximo de iterações for atingido.
# .
# - maximo de iteracaoes
# - precisão
criteria = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 10, 1.0)
#Aplicacao do Kmeans
# - Entrada
# - Numero de clusters
# - Melhores labels
# - Criterio
# - Iteracoes
# - Definicao dos centros iniciais
#
# Output
# - distance: soma da distância ao quadrado de cada ponto
# até seus centros correspondentes.
# - label: vetor de labels
# - center: vetor de centros dos clusters
distance, label, center = cv2.kmeans(Z, K, None, criteria, 10,
cv2.KMEANS_RANDOM_CENTERS)
#Conversao para uint8 novamente
center = np.uint8(center)
#Obtendo imagem de saida
output = center[label.flatten()].reshape((image.shape))
lab1.viewImages([image, output], ['Imagem de entrada', 'Kmeans'])
return saveChanges(image, output)
def bilateral(image):
'''
Input: image
'''
diametro = int(input("Entre com o diâmetro: "))
sigma_color = float(input("Entre com o valor sigmaColor: "))
sigma_space = float(input("Entre com o valor sigmaSpace: "))
# aplica filtro
bilat = cv2.bilateralFilter(image, diametro, sigma_color, sigma_space)
lab1.viewImages([image, bilat], ['Imagem original', 'Filtro Bilateral'])
return saveChanges(image, bilat)
def filterGaussian(img):
'''
Input: img - imagem;
sigmaX - desvio padrão na direção x
sigmaY - desvio padrão na direção y
Obs.: Se apenas o sigmaX for especificado, o sigmaY será considerado igual ao sigmaX.
Pelo menos o sigmaX deve, obrigatoriamente, ser especificado.
Output: None
'''
print()
#recebe a dimensao da mascara
mascara = int(input("Qual a mascara? ex.: 3 ou 5 ou 7 - APENAS valor ímpar > 3. \n --> "))
#opções de desvio
option = int(input("""
1: Entrar com desvio de X e Y
2: Entrar apenas com desvio de X
Opção: """))
if(option == 1):
stdX = float(input("Qualo valor do desvio padrão de X ? "))
stdY = float(input("Qualo valor do desvio padrão de Y ? "))
#aplica a filtragem gaussiana
gaussian = cv2.GaussianBlur(img,(mascara,mascara),stdX, stdY)
elif(option == 2):
stdX = int(input("Qualo valor do desvio padrão de X ? "))
#aplica a filtragem gaussiana
gaussian = cv2.GaussianBlur(img,(mascara,mascara),stdX)
'''
#concatena a imagem original com a imagem que passou pelo processo de filtragem
compare = np.concatenate((img, gaussian),axis=1)
#define titulo da imagem
title = ('Imagem original x Imagem apos Filtro Gaussiano %d' %mascara)
#plot image
cv2.imshow(title , compare)
cv2.waitKey(0)
cv2.destroyAllWindows()
'''
lab1.viewImages([img, gaussian], ['Imagem original', 'Imagem apos Filtro Gaussiano %f' %mascara])
return saveChanges(img, gaussian)
def canny(image):
'''
Input: image
'''
lowThreshold = float(input("Entre com o valor de lowThreshold: "))
highThreshold = float(input("Entre com o valor de highThreshold: "))
# converte a imagem para cinza, se ela ja não for
if len(image.shape) > 2:
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
else:
gray = image
# aplica filtro
canny = cv2.Canny(gray, lowThreshold, highThreshold)
lab1.viewImages([image, canny], ['Imagem original', 'Canny'])
return saveChanges(image, canny)
def laplaciano(img):
#se imagem for colorida, converte para escala gray
if len(img.shape) > 2:
imgGray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
#aplica o filtro
kernel = 3 #dimensoes da mascara
resultado3 = cv2.Laplacian(imgGray, cv2.CV_64F, ksize=kernel)
#converte para unsigned int de 8 bits
resultado3 = np.uint8(np.absolute(resultado3))
#aplica o filtro
kernel = 5
resultado5 = cv2.Laplacian(imgGray, cv2.CV_64F, ksize=kernel)
#converte para unsigned int de 8 bits
resultado5 = np.uint8(np.absolute(resultado5))
#aplica o filtro
kernel = 7
resultado7 = cv2.Laplacian(imgGray, cv2.CV_64F, ksize=kernel)
#converte para unsigned int de 8 bits
resultado7 = np.uint8(np.absolute(resultado7))
#exibe a imagem original e a resultado
lab1.viewImages([imgGray, resultado3,resultado5, resultado7], ['Imagem(gray)',
'Laplaciano 3x3',
'Laplaciano 5x5',
'Laplaciano 7x7'])
#empilha as imagens resultado
images = np.vstack([resultado3,resultado5, resultado7])
return saveChanges(img,images)
def menu():
choice = ''
images = [None, None]
names = ['', '']
while (choice != 'Q' and choice != 'q'):
print("************MENU**************")
#time.sleep(1)
print()
choice = input("""
A: Carregar imagem
B: Exibir imagem
C: Salvar imagem
D: Detecção de descontinuidades e limiarização
E: Transformada de Hough
F: K-means
Q: Sair
Imagens no sistema: %s
Opção: """ % str(names))
if choice == "Q" or choice == "q":
sys.exit
elif choice == "A" or choice == "a":
n = 1 - options(images, names,
'Qual das imagens deseja sobrescrever?')
images[n], names[n] = lab1.loadImage()
elif images[0] is None and images[1] is None:
print('Nenhuma imagem no sistema')
print('<Pressione ENTER para continuar>')
input()
elif choice == "B" or choice == "b":
if images[1] is None:
lab1.viewImage(images[0], names[0])
elif images[0] is None:
lab1.viewImage(images[1], names[1])
else:
lab1.viewImages(images, names)
elif choice == "C" or choice == "c":
n = options(images, names, 'Qual das imagens deseja salvar?')
lab1.saveImage(images[n])
elif choice == "D" or choice == "d":
n = options(
images, names,
'Qual das imagens será aplicada detecção de descontinuidades e limiarização?'
)
images[n] = descontinuidade(images[n])
elif choice == "E" or choice == "e":
check = False
while (not check):
choice = input("""
Qual tranformada aplicar?
Circulos(C) ou Linhas(L): """)
if choice == 'L' or choice == 'l':
check = True
n = options(
images, names,
'Qual das imagens será aplicado a Transformada de Hough?'
)
print("""
Transformada de Hough(linhas)\n""")
limiar = int(input("Qual o valor do limiar?"))
images[n] = houghLinhas(images[n], limiar)
elif choice == 'C' or choice == 'c':
check = True
n = options(
images, names,
'Qual das imagens será aplicado a Transformada de Hough?'
)
print("""
Transformada de Hough(circulos)\n""")
raioMin = int(
input("Qual o valor do raio minimo? (recomendado: 1)"))
raioMax = int(
input(
"Qual o valor do raio maximo? (recomendado: 50)"))
images[n] = houghCirculos(images[n], raioMin, raioMax)
else:
print("Opcao invalida")
elif choice == "F" or choice == "f":
n = options(images, names,
'Qual das imagens será aplicado o K-Means?')
check = False
while (not check):
choice = input("""
Deseja usar a imagem em tons de cinza?
Sim(S) ou Nao(N): """)
if choice == 'S' or choice == 's':
check = True
gray = True
elif choice == 'N' or choice == 'n':
check = True
gray = False
K = int(input("Numero de regioes: "))
images[n] = kmeans(images[n], gray, K)
else:
print("You must only select either A,B,C,D,E,F,G or Q.")
print("Please try again")
def kirsch(image):
# converte a imagem para cinza, se ela ja não for
if len(image.shape) > 2:
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
else:
gray = image
# cria as 8 máscaras
kernelG1 = np.array([[5, -3, -3], [5, 0, -3], [5, -3, -3]],
dtype=np.float32)
kernelG2 = np.array([[-3, -3, -3], [5, 0, -3], [5, 5, -3]],
dtype=np.float32)
kernelG3 = np.array([[-3, -3, -3], [-3, 0, -3], [5, 5, 5]],
dtype=np.float32)
kernelG4 = np.array([[-3, -3, -3], [-3, 0, 5], [-3, 5, 5]],
dtype=np.float32)
kernelG5 = np.array([[-3, -3, 5], [-3, 0, 5], [-3, -3, 5]],
dtype=np.float32)
kernelG6 = np.array([[-3, 5, 5], [-3, 0, 5], [-3, -3, -3]],
dtype=np.float32)
kernelG7 = np.array([[5, 5, 5], [-3, 0, -3], [-3, -3, -3]],
dtype=np.float32)
kernelG8 = np.array([[5, 5, -3], [5, 0, -3], [-3, -3, -3]],
dtype=np.float32)
# aplica as 8 máscaras do filtro kirsc
norm = cv2.NORM_MINMAX
g1 = cv2.normalize(cv2.filter2D(gray, cv2.CV_32F, kernelG1), None, 0, 255,
norm, cv2.CV_8UC1)
g2 = cv2.normalize(cv2.filter2D(gray, cv2.CV_32F, kernelG2), None, 0, 255,
norm, cv2.CV_8UC1)
g3 = cv2.normalize(cv2.filter2D(gray, cv2.CV_32F, kernelG3), None, 0, 255,
norm, cv2.CV_8UC1)
g4 = cv2.normalize(cv2.filter2D(gray, cv2.CV_32F, kernelG4), None, 0, 255,
norm, cv2.CV_8UC1)
g5 = cv2.normalize(cv2.filter2D(gray, cv2.CV_32F, kernelG5), None, 0, 255,
norm, cv2.CV_8UC1)
g6 = cv2.normalize(cv2.filter2D(gray, cv2.CV_32F, kernelG6), None, 0, 255,
norm, cv2.CV_8UC1)
g7 = cv2.normalize(cv2.filter2D(gray, cv2.CV_32F, kernelG7), None, 0, 255,
norm, cv2.CV_8UC1)
g8 = cv2.normalize(cv2.filter2D(gray, cv2.CV_32F, kernelG8), None, 0, 255,
norm, cv2.CV_8UC1)
# pega os valores máximos de cada resultado
grad = cv2.max(g1, g2)
grad = cv2.max(grad, g3)
grad = cv2.max(grad, g4)
grad = cv2.max(grad, g5)
grad = cv2.max(grad, g6)
grad = cv2.max(grad, g7)
grad = cv2.max(grad, g8)
# exibe as imagens
lab1.viewImages([image, grad],
['Imagem original', 'Kirsch valores absolutos'])
return saveChanges(image, grad)
def menu():
choice = ''
images = [None, None]
names = ['', '']
while (choice is not 'Q' and choice is not 'q'):
print("************MENU**************")
#time.sleep(1)
print()
choice = input("""
A: Carregar imagem
B: Exibir imagem
C: Salvar imagem
D: Filtro morfológico de erosão
E: Filtro morfológico de dilatação
F: Filtro Prewitt
G: Filtro Kirsch
H: Filtro de Canny
I: Filtro bilateral
Q: Sair
Imagens no sistema: %s
Opção: """ % str(names))
if choice == "Q" or choice == "q":
sys.exit
elif choice == "A" or choice == "a":
n = 1 - options(images, names,
'Qual das imagens deseja sobrescrever?')
images[n], names[n] = lab1.loadImage()
elif images[0] is None and images[1] is None:
print('Nenhuma imagem no sistema')
print('<Pressione ENTER para continuar>')
input()
elif choice == "B" or choice == "b":
if images[1] is None:
lab1.viewImage(images[0], names[0])
elif images[0] is None:
lab1.viewImage(images[1], names[1])
else:
lab1.viewImages(images, names)
elif choice == "C" or choice == "c":
n = options(images, names, 'Qual das imagens deseja salvar?')
lab1.saveImage(images[n])
elif choice == "D" or choice == "d":
n = options(images, names,
'Qual das imagens será aplicado o filtro de erosão?')
print("Erosão\n")
mask = int(
input(
"Qual o tamanho da máscara? ex.: 5 - vai ser uma máscara 5x5 \n -->"
))
mask = (mask, mask)
tipo = -1
tipo = int(
input(
"Qual o formato da máscara? 0: retangular; 1: elíptica; 2:cruz. \n -->"
))
images[n] = erosao(images[n], mask, tipo)
elif choice == "E" or choice == "e":
n = options(
images, names,
'Qual das imagens será aplicado o filtro de dilatação?')
print("Dilatação\n")
mask = int(
input(
"Qual o tamanho da máscara? ex.: 5 - vai ser uma máscara 5x5 \n -->"
))
mask = (mask, mask)
tipo = -1
tipo = int(
input(
"Qual o formato da máscara? 0: retangular; 1: elíptica; 2:cruz. \n -->"
))
images[n] = dilatar(images[n], mask, tipo)
elif choice == "F" or choice == "f":
n = options(
images, names,
'Qual das imagens será aplicado o filtro de dilatação?')
images[n] = prewitt(images[n])
elif choice == "G" or choice == "g":
n = options(
images, names,
'Qual das imagens será aplicado o filtro de dilatação?')
images[n] = kirsch(images[n])
elif choice == "H" or choice == "h":
n = options(images, names,
'Qual das imagens será aplicado o filtro de Canny?')
images[n] = canny(images[n])
elif choice == "I" or choice == "i":
n = options(images, names,
'Qual das imagens será aplicado o filtro bilateral?')
images[n] = bilateral(images[n])
else:
print("You must only select either A,B,C,D,E,F,G or Q.")
print("Please try again")
def menu():
choice = ''
images = [None , None]
names = ['', '']
while(choice is not 'Q' and choice is not 'q'):
print("************MENU**************")
#time.sleep(1)
print()
choice = input("""
A: Carregar imagem
B: Exibir imagem
C: Salvar imagem
D: Filtro de Mediana
E: Exibir múltiplos filtros de mediana
F: Filtro de Média
G: Filtro Gaussiano
H: Filtro Sobel
I: Filtro Laplaciano
Q: Sair
Imagens no sistema: %s
Opção: """ % str(names))
if choice=="Q" or choice=="q":
sys.exit
elif choice == "A" or choice =="a":
n = 1 - options(images, names, 'Qual das imagens deseja sobrescrever?')
images[n], names[n] = lab1.loadImage()
elif images[0] is None and images[1] is None:
print('Nenhuma imagem no sistema')
print('<Pressione ENTER para continuar>')
input()
elif choice == "B" or choice =="b":
if images[1] is None:
lab1.viewImage(images[0], names[0])
elif images[0] is None:
lab1.viewImage(images[1], names[1])
else:
lab1.viewImages(images, names)
elif choice == "C" or choice =="c":
n = options(images, names, 'Qual das imagens deseja salvar?')
lab1.saveImage(images[n])
elif choice=="D" or choice=="d":
n = options(images, names, 'Qual das imagens será aplicado o filtro de mediana?')
images[n] = calcMaskMedianaUnico(images[n])
elif choice=="E" or choice=="e":
n = options(images, names, 'Qual das imagens serão aplicados vários filtros de mediana para serem exibidos??')
exibirMultiplasMaskMediana(images[n])
elif choice=="F" or choice=="f":
n = options(images, names, 'Qual das imagens será aplicado o filtro de Média?')
images[n] = calcMaskMedia(images[n])
elif choice=="G" or choice=="g":
n = options(images, names, 'Qual das imagens será aplicado o filtro Gaussiano?')
images[n] = filterGaussian(images[n])
elif choice=="H" or choice=="h":
n = options(images, names, 'Qual das imagens será aplicado o filtro Sobel?')
images[n] = sobel(images[n])
elif choice=="I" or choice=="i":
n = options(images, names, 'Qual das imagens será aplicado o filtro Laplaciano?')
images[n] = laplaciano(images[n])
else:
print("You must only select A to I or Q.")
print("Please try again")
def menu():
choice = ''
images = [None, None]
names = ['', '']
while (choice is not 'Q' and choice is not 'q'):
print("************MENU**************")
#time.sleep(1)
print()
choice = input("""
A: Carregar imagem
B: Exibir imagem
C: Salvar imagem
D: Exibir negativo
E: Equalizar histograma
F: Transformação de Intensidade Gray
G: Transformação de Potencia
H: Binarização de Imagem
Q: Sair
Imagens no sistema: %s
Opção: """ % str(names))
if choice == "Q" or choice == "q":
sys.exit
elif choice == "A" or choice == "a":
n = 1 - options(images, names,
'Qual das imagens deseja sobrescrever?')
images[n], names[n] = lab1.loadImage()
elif images[0] is None and images[1] is None:
print('Nenhuma imagem no sistema')
print('<Pressione ENTER para continuar>')
input()
elif choice == "B" or choice == "b":
if images[1] is None:
lab1.viewImage(images[0], names[0])
elif images[0] is None:
lab1.viewImage(images[1], names[1])
else:
lab1.viewImages(images, names)
elif choice == "C" or choice == "c":
n = options(images, names, 'Qual das imagens deseja salvar?')
lab1.saveImage(images[n])
elif choice == "D" or choice == "d":
n = options(images, names, 'Qual das imagens será negativa?')
images[n] = negative(images[n])
elif choice == "E" or choice == "e":
n = options(images, names, 'Qual das imagens será equalizada?')
if len(images[n].shape) < 3:
images[n] = equalizeHist_gray(images[n])
else:
images[n] = equalizeHist(images[n])
elif choice == "F" or choice == "f":
n = options(images, names,
'Qual das imagens será transformada (gray)?')
mudar = input(
"Deseja mudar os intervalos e valores da transformada (s/n)? ")
if mudar == 's' or mudar == 'S':
a, b, alfa, beta, charlie = input(
"Qual é o valor do limiar (faixa de valores) 'a' e 'b', e quais os novos valores serão atribuídos aos intervalos 1, 2 e 3? [escrever em uma linha, separado por vírgula] "
)
images[n] = trans_intensidade_gray(images[n])
elif choice == "G" or choice == "g":
n = options(images, names, 'Qual das imagens será transformada?')
images[n] = trans_potencia(images[n])
elif choice == "H" or choice == "h":
n = options(images, names, 'Qual das imagens será binarizada?')
value = input('Limiar? (0 < limiar < 255) :')
value = int(value)
if value > 0 and value < 255:
images[n] = lab1.binarizar(images[n], value)
#images[n] = binarizar_gray(images[n],float(limiar))
else:
print("You must only select either A,B,C,D,E,F,G,H or Q.")
print("Please try again")
def menu():
choice = ''
images = [None, None]
names = ['', '']
while (choice is not 'Q' and choice is not 'q'):
print("************MENU**************")
#time.sleep(1)
print()
choice = input("""
A: Carregar imagem
B: Exibir imagem
C: Salvar imagem
D: Exibir Histograms
E: Calcular imagem-diferença, erro médio quadrático e PSNR
F: Alterar a intensidade
G: Alterar o brilho
H: Fazer sub-amostragem
I: Binarizar
J: Exibir negativo
K: Equalizar histograma
L: Transformação de Intensidade Gray
M: Transformação de Potencia
N: Filtro de Mediana
O: Exibir múltiplos filtros de mediana
P: Filtro de Média
R: Filtro Gaussiano
S: Filtro Sobel
T: Filtro Laplaciano
Q: Sair
Imagens no sistema: %s
Opção: """ % str(names))
if choice == "Q" or choice == "q":
sys.exit
elif choice == "A" or choice == "a":
n = 1 - options(images, names,
'Qual das imagens deseja sobrescrever?')
images[n], names[n] = lab1.loadImage()
elif images[0] is None and images[1] is None:
print('Nenhuma imagem no sistema')
print('<Pressione ENTER para continuar>')
input()
elif choice == "B" or choice == "b":
if images[1] is None:
lab1.viewImage(images[0], names[0])
elif images[0] is None:
lab1.viewImage(images[1], names[1])
else:
lab1.viewImages(images, names)
elif choice == "C" or choice == "c":
n = options(images, names, 'Qual das imagens deseja salvar?')
lab1.saveImage(images[n])
elif choice == "D" or choice == "d":
lab1.viewHistograms(images[0])
lab1.viewHistograms(images[1])
elif choice == "E" or choice == "e":
option = 'A'
if images[0] is None or images[1] is None:
print(
'Sao necessarias duas imagens no sistema para calcular a diferenca'
)
option = input('Deseja carregar outra imagem ? A:sim B:nao :')
if (option == 'A' or option == 'a') and images[0] is None:
images[0], names[0] = lab1.loadImage()
elif (option == 'A' or option == 'a') and images[1] is None:
images[1], names[1] = lab1.loadImage()
if (option == 'A' or option == 'a'
) and images[0] is not None and images[1] is not None:
lab1.calImgDif(images[0], images[1])
elif choice == "F" or choice == "f":
n = options(images, names,
'Qual das imagens deseja alterar a intensidade?')
value = 0
print(
'(Utilize valor negativo para diminuir e positivo para aumentar)'
)
value = input(
'A intensidade será alterada em quanto? [-255,255] :')
value = int(value)
if value >= -255 and value <= 255:
images[n] = lab1.itensidade(images[n], abs(value), (value > 0))
elif choice == "G" or choice == "g":
n = options(images, names,
'Qual das imagens deseja alterar o brilho?')
print(
'(Utilize valor negativo para diminuir e positivo para aumentar)'
)
value = input('O brilho será alterado em quanto? [-255,255] :')
value = int(value)
if value >= -255 and value <= 255:
images[n] = lab1.brightness(images[n], abs(value), (value > 0))
elif choice == "H" or choice == "h":
n = options(images, names,
'Qual das imagens deseja alterar a amostragem?')
print(
' O valor de amostragem, aqui, representa, aproximadamente, quantos pixels serão unidos em x e y.'
)
print(
' Este valor é aproximado porque as dimensoes da imagem podem não ser multiplas do valor da amostragem'
)
value = input(
'A amostragem será alterado em quanto? (0 < amostragem) :')
value = int(value)
if value > 0:
images[n] = lab1.subamostragem(images[n], value)
elif choice == 'I' or choice == 'i':
n = options(images, names,
'Qual das imagens deseja alterar o limiar?')
value = input('Limiar? (0 < limiar < 255) :')
value = int(value)
if value > 0 and value < 255:
images[n] = lab1.binarizar(images[n], value)
elif choice == "J" or choice == "j":
n = options(images, names, 'Qual das imagens será negativa?')
images[n] = lab2.negative(images[n])
elif choice == "K" or choice == "k":
n = options(images, names, 'Qual das imagens será equalizada?')
if len(images[n].shape) < 3:
images[n] = lab2.equalizeHist_gray(images[n])
else:
images[n] = lab2.equalizeHist(images[n])
elif choice == "L" or choice == "l":
n = options(images, names,
'Qual das imagens será transformada (gray)?')
mudar = input(
"Deseja mudar os intervalos e valores da transformada (s/n)? ")
if mudar == 's' or mudar == 'S':
a, b, alfa, beta, charlie = input(
"Qual é o valor do limiar (faixa de valores) 'a' e 'b', e quais os novos valores serão atribuídos aos intervalos 1, 2 e 3? [escrever em uma linha, separado por vírgula] "
)
images[n] = lab2.trans_intensidade_gray(images[n])
elif choice == "M" or choice == "m":
n = options(images, names, 'Qual das imagens será transformada?')
images[n] = lab2.trans_potencia(images[n])
elif choice == "N" or choice == "n":
n = options(images, names,
'Qual das imagens será aplicado o filtro de mediana?')
images[n] = lab3.calcMaskMedianaUnico(images[n])
elif choice == "O" or choice == "o":
n = options(
images, names,
'Qual das imagens serão aplicados vários filtros de mediana para serem exibidos??'
)
lab3.exibirMultiplasMaskMediana(images[n])
elif choice == "P" or choice == "p":
n = options(images, names,
'Qual das imagens será aplicado o filtro de Média?')
images[n] = lab3.calcMaskMedia(images[n])
elif choice == "R" or choice == "r":
n = options(images, names,
'Qual das imagens será aplicado o filtro Gaussiano?')
images[n] = lab3.filterGaussian(images[n])
elif choice == "S" or choice == "s":
n = options(images, names,
'Qual das imagens será aplicado o filtro Sobel?')
images[n] = lab3.sobel(images[n])
elif choice == "T" or choice == "t":
n = options(images, names,
'Qual das imagens será aplicado o filtro Laplaciano?')
images[n] = lab3.laplaciano(images[n])
else:
print("You must only select A to T.")
print("Please try again")