Commit b723afd0 authored by Everton Castelão Tetila's avatar Everton Castelão Tetila 💬
Browse files

modulo de classificacao que utiliza descritores locais, bovw e svm

parent 600fde02
import cv2
import numpy as np
from os.path import join
import os
# placeholder path
datapath1 = "../data/demo/train/percevejoMarrom"
def path1(cls,i):
return "%s/%s%d.pgm" % (datapath1,cls,i+1)
mar = "mar-"
datapath2 = "../data/demo/train/vaquinha"
def path2(cls,i):
return "%s/%s%d.pgm" % (datapath2,cls,i+1)
vaq = "vaq-"
datapath3 = "../data/demo/train/percevejoVerde"
def path3(cls,i):
return "%s/%s%d.pgm" % (datapath3,cls,i+1)
ver = "ver-"
detect = cv2.xfeatures2d.SIFT_create()
extract = cv2.xfeatures2d.SIFT_create()
flann_params = dict(algorithm = 1, trees = 5)
flann = cv2.FlannBasedMatcher(flann_params, {})
bow_kmeans_trainer = cv2.BOWKMeansTrainer(500) # Este treinador de BOW utiliza 500 clusters para 500 palavras visuais
extract_bow = cv2.BOWImgDescriptorExtractor(extract, flann)
def extract_sift(fn):
im = cv2.imread(fn,0)
return extract.compute(im, detect.detect(im))[1]
for i in range(10):
bow_kmeans_trainer.add(extract_sift(path1(mar,i)))
bow_kmeans_trainer.add(extract_sift(path2(vaq,i)))
bow_kmeans_trainer.add(extract_sift(path3(ver,i)))
voc = bow_kmeans_trainer.cluster()
extract_bow.setVocabulary( voc )
def bow_features(fn):
im = cv2.imread(fn,0)
return extract_bow.compute(im, detect.detect(im))
traindata, trainlabels = [],[]
for i in range(20):
traindata.extend(bow_features(path1(mar, i))); trainlabels.append(1)
traindata.extend(bow_features(path2(vaq, i))); trainlabels.append(-1)
traindata.extend(bow_features(path3(ver, i))); trainlabels.append(0)
svm = cv2.ml.SVM_create()
svm.train(np.array(traindata), cv2.ml.ROW_SAMPLE, np.array(trainlabels))
def predict(fn):
f = bow_features(fn);
p = svm.predict(f)
print fn, "\t", p[1][0][0]
return p
# inicializacao de variaveis de controle
resp = 0
cont = 0
total = 0
# carrega todas as imagens da pasta e classifica
mypath = os.path.join('../data/demo/test/vaquinha')
for item in os.listdir(mypath):
if '.png' in item:
inseto = os.path.join(mypath, item)
inseto_img = cv2.imread(inseto)
inseto_predict = predict(inseto)
# acertou a classe correta (percevejoMarrom == 1.0) (percevejoVerde == 0.0) (vaquinha == -1.0)
if (inseto_predict[1][0][0] == 1.0):
resp = 1
# errou a classe correta
else:
resp = 0
# conta as imagens classificadas corretamente
cont = resp + cont
total = total + 1
acc = cont/float(total)
print 'ACC:', acc
font = cv2.FONT_HERSHEY_SIMPLEX
# escreve na imagem a classe prevista
if (inseto_predict[1][0][0] == 1.0):
cv2.putText(inseto_img,'Percevejo Marrom',(10,30), font, 1,(0,255,0),2,cv2.LINE_AA)
if (inseto_predict[1][0][0] == -1.0):
cv2.putText(inseto_img,'Vaquinha',(10,30), font, 1,(0,0, 255),2,cv2.LINE_AA)
if (inseto_predict[1][0][0] == 0.0):
cv2.putText(inseto_img,'Percevejo Verde',(10,30), font, 1,(255,0,0),2,cv2.LINE_AA)
cv2.imshow('BOW + SVM Success', inseto_img)
cv2.waitKey(0)
cv2.destroyAllWindows()
import cv2
import numpy as np
from os.path import join
import os
# placeholder path
datapath1 = "../data/demo/train/percevejoMarrom"
def path1(cls,i):
return "%s/%s%d.pgm" % (datapath1,cls,i+1)
mar = "mar-"
datapath2 = "../data/demo/train/vaquinha"
def path2(cls,i):
return "%s/%s%d.pgm" % (datapath2,cls,i+1)
vaq = "vaq-"
datapath3 = "../data/demo/train/percevejoVerde"
def path3(cls,i):
return "%s/%s%d.pgm" % (datapath3,cls,i+1)
ver = "ver-"
detect = cv2.xfeatures2d.SURF_create()
extract = cv2.xfeatures2d.SURF_create()
flann_params = dict(algorithm = 1, trees = 5)
flann = cv2.FlannBasedMatcher(flann_params, {})
bow_kmeans_trainer = cv2.BOWKMeansTrainer(500) # Este treinador de BOW utiliza 500 clusters para 500 palavras visuais
extract_bow = cv2.BOWImgDescriptorExtractor(extract, flann)
def extract_surf(fn):
im = cv2.imread(fn,0)
return extract.compute(im, detect.detect(im))[1]
for i in range(10):
bow_kmeans_trainer.add(extract_surf(path1(mar,i)))
bow_kmeans_trainer.add(extract_surf(path2(vaq,i)))
bow_kmeans_trainer.add(extract_surf(path3(ver,i)))
voc = bow_kmeans_trainer.cluster()
extract_bow.setVocabulary( voc )
def bow_features(fn):
im = cv2.imread(fn,0)
return extract_bow.compute(im, detect.detect(im))
traindata, trainlabels = [],[]
for i in range(20):
traindata.extend(bow_features(path1(mar, i))); trainlabels.append(1)
traindata.extend(bow_features(path2(vaq, i))); trainlabels.append(-1)
traindata.extend(bow_features(path3(ver, i))); trainlabels.append(0)
svm = cv2.ml.SVM_create()
svm.train(np.array(traindata), cv2.ml.ROW_SAMPLE, np.array(trainlabels))
def predict(fn):
f = bow_features(fn);
p = svm.predict(f)
print fn, "\t", p[1][0][0]
return p
# inicializacao de variaveis de controle
resp = 0
cont = 0
total = 0
# carrega todas as imagens da pasta e classifica
mypath = os.path.join('../data/demo/test/vaquinha')
for item in os.listdir(mypath):
if '.png' in item:
inseto = os.path.join(mypath, item)
inseto_img = cv2.imread(inseto)
inseto_predict = predict(inseto)
# acertou a classe correta (percevejoMarrom == 1.0) (percevejoVerde == 0.0) (vaquinha == -1.0)
if (inseto_predict[1][0][0] == 1.0):
resp = 1
# errou a classe correta
else:
resp = 0
# conta as imagens classificadas corretamente
cont = resp + cont
total = total + 1
acc = cont/float(total)
print 'ACC:', acc
font = cv2.FONT_HERSHEY_SIMPLEX
# escreve na imagem a classe prevista
if (inseto_predict[1][0][0] == 1.0):
cv2.putText(inseto_img,'Percevejo Marrom',(10,30), font, 1,(0,255,0),2,cv2.LINE_AA)
if (inseto_predict[1][0][0] == -1.0):
cv2.putText(inseto_img,'Vaquinha',(10,30), font, 1,(0,0, 255),2,cv2.LINE_AA)
if (inseto_predict[1][0][0] == 0.0):
cv2.putText(inseto_img,'Percevejo Verde',(10,30), font, 1,(255,0,0),2,cv2.LINE_AA)
cv2.imshow('BOW + SVM Success', inseto_img)
cv2.waitKey(0)
cv2.destroyAllWindows()
#######################################################################################################################################
# Autor: Everton Castelão Tetila #
# Software: Template Matching #
# Curso: Doutorado em Desenvolvimento Local #
# Orientador: Hemerson Pistori #
#######################################################################################################################################
import cv2
import numpy as np
import sys
from Tkinter import *
import Tkinter, Tkconstants, tkFileDialog, tkMessageBox
from PIL import Image, ImageTk
from resizeimage import resizeimage
from matplotlib import pyplot as plt
from numpy import array, arange, sin, pi
from os.path import join
from os import walk
from sys import argv
from scipy import signal
# Definição de variáveis globais
mGui = Tk() # Objeto de menu inicial
path1 = StringVar() # Variável de texto
path2 = StringVar() # Variável de texto
mvar1 = IntVar() # Variável de inteiro
mvar2 = IntVar() # Variável de inteiro
mGui.geometry('800x600+250+50') # Dimensões da janela de menu
mGui.title('Template Matching BOW e SVM') # Título da janela de menu
opcao = IntVar()
def mDetect(): # Janela de menu
global opcao
op = opcao.get()
if (op == 1):
Sift()
else:
if (op == 2):
Surf()
else:
if (op == 3):
Fast()
else:
if (op == 4):
Orb()
else:
tkMessageBox.showinfo(title="Opção",message="Escolha o algoritmo de detecção!")
return
def mClassifica_sift(): # Funcao que executa a classificacao da imagem com BOW e SVM
# placeholder path
datapath1 = "../data/demo/train/percevejoMarrom"
def path1(cls,i):
return "%s/%s%d.pgm" % (datapath1,cls,i+1)
mar = "mar-"
datapath2 = "../data/demo/train/vaquinha"
def path2(cls,i):
return "%s/%s%d.pgm" % (datapath2,cls,i+1)
vaq = "vaq-"
datapath3 = "../data/demo/train/percevejoVerde"
def path3(cls,i):
return "%s/%s%d.pgm" % (datapath3,cls,i+1)
ver = "ver-"
detect = cv2.xfeatures2d.SIFT_create()
extract = cv2.xfeatures2d.SIFT_create()
flann_params = dict(algorithm = 1, trees = 5)
flann = cv2.FlannBasedMatcher(flann_params, {})
bow_kmeans_trainer = cv2.BOWKMeansTrainer(500) # Este treinador de BOW utiliza 500 clusters para 500 palavras visuais
extract_bow = cv2.BOWImgDescriptorExtractor(extract, flann)
def extract_sift(fn):
im = cv2.imread(fn,0)
return extract.compute(im, detect.detect(im))[1]
for i in range(10):
bow_kmeans_trainer.add(extract_sift(path1(mar,i)))
bow_kmeans_trainer.add(extract_sift(path2(vaq,i)))
bow_kmeans_trainer.add(extract_sift(path3(ver,i)))
voc = bow_kmeans_trainer.cluster()
extract_bow.setVocabulary( voc )
def bow_features(fn):
im = cv2.imread(fn,0)
return extract_bow.compute(im, detect.detect(im))
traindata, trainlabels = [],[]
for i in range(20):
traindata.extend(bow_features(path1(mar, i))); trainlabels.append(1)
traindata.extend(bow_features(path2(vaq, i))); trainlabels.append(-1)
traindata.extend(bow_features(path3(ver, i))); trainlabels.append(0)
svm = cv2.ml.SVM_create()
svm.train(np.array(traindata), cv2.ml.ROW_SAMPLE, np.array(trainlabels))
def predict(fn):
f = bow_features(fn);
p = svm.predict(f)
print fn, "\t", p[1][0][0]
return p
inseto_img = cv2.imread(meuAbrir)
inseto = meuAbrir
inseto_predict = predict(inseto)
font = cv2.FONT_HERSHEY_SIMPLEX
# escreve na imagem a classe prevista
if (inseto_predict[1][0][0] == 1.0):
cv2.putText(inseto_img,'Percevejo Marrom',(10,30), font, 1,(0,255,0),2,cv2.LINE_AA)
if (inseto_predict[1][0][0] == -1.0):
cv2.putText(inseto_img,'Vaquinha',(10,30), font, 1,(0,0, 255),2,cv2.LINE_AA)
if (inseto_predict[1][0][0] == 0.0):
cv2.putText(inseto_img,'Percevejo Verde',(10,30), font, 1,(255,0,0),2,cv2.LINE_AA)
inseto_img = cv2.cvtColor(inseto_img,cv2.COLOR_BGR2RGB) # Converte as bandas da imagens BGR para RGB
img = Image.fromarray(inseto_img) # Converte o tipo da imagem cv2 para PIL
img = resizeimage.resize_contain(img, [770, 400]) # Redimensiona a imagem original para o tamanho especificado
tkimage = ImageTk.PhotoImage(img)
myvar=Label(mGui,image = tkimage)
myvar.image = tkimage
myvar.place(x=10,y=150) # Posiciona a imagem na janela
return
def mClassifica_surf(): # Funcao que executa a classificacao da imagem com BOW e SVM
# placeholder path
datapath1 = "../data/demo/train/percevejoMarrom"
def path1(cls,i):
return "%s/%s%d.pgm" % (datapath1,cls,i+1)
mar = "mar-"
datapath2 = "../data/demo/train/vaquinha"
def path2(cls,i):
return "%s/%s%d.pgm" % (datapath2,cls,i+1)
vaq = "vaq-"
datapath3 = "../data/demo/train/percevejoVerde"
def path3(cls,i):
return "%s/%s%d.pgm" % (datapath3,cls,i+1)
ver = "ver-"
detect = cv2.xfeatures2d.SURF_create()
extract = cv2.xfeatures2d.SURF_create()
flann_params = dict(algorithm = 1, trees = 5)
flann = cv2.FlannBasedMatcher(flann_params, {})
bow_kmeans_trainer = cv2.BOWKMeansTrainer(500) # Este treinador de BOW utiliza 500 clusters para 500 palavras visuais
extract_bow = cv2.BOWImgDescriptorExtractor(extract, flann)
def extract_sift(fn):
im = cv2.imread(fn,0)
return extract.compute(im, detect.detect(im))[1]
for i in range(10):
bow_kmeans_trainer.add(extract_sift(path1(mar,i)))
bow_kmeans_trainer.add(extract_sift(path2(vaq,i)))
bow_kmeans_trainer.add(extract_sift(path3(ver,i)))
voc = bow_kmeans_trainer.cluster()
extract_bow.setVocabulary( voc )
def bow_features(fn):
im = cv2.imread(fn,0)
return extract_bow.compute(im, detect.detect(im))
traindata, trainlabels = [],[]
for i in range(20):
traindata.extend(bow_features(path1(mar, i))); trainlabels.append(1)
traindata.extend(bow_features(path2(vaq, i))); trainlabels.append(-1)
traindata.extend(bow_features(path3(ver, i))); trainlabels.append(0)
svm = cv2.ml.SVM_create()
svm.train(np.array(traindata), cv2.ml.ROW_SAMPLE, np.array(trainlabels))
def predict(fn):
f = bow_features(fn);
p = svm.predict(f)
print fn, "\t", p[1][0][0]
return p
inseto_img = cv2.imread(meuAbrir)
inseto = meuAbrir
inseto_predict = predict(inseto)
font = cv2.FONT_HERSHEY_SIMPLEX
# escreve na imagem a classe prevista
if (inseto_predict[1][0][0] == 1.0):
cv2.putText(inseto_img,'Percevejo Marrom',(10,30), font, 1,(0,255,0),2,cv2.LINE_AA)
if (inseto_predict[1][0][0] == -1.0):
cv2.putText(inseto_img,'Vaquinha',(10,30), font, 1,(0,0, 255),2,cv2.LINE_AA)
if (inseto_predict[1][0][0] == 0.0):
cv2.putText(inseto_img,'Percevejo Verde',(10,30), font, 1,(255,0,0),2,cv2.LINE_AA)
inseto_img = cv2.cvtColor(inseto_img,cv2.COLOR_BGR2RGB) # Converte as bandas da imagens BGR para RGB
img = Image.fromarray(inseto_img) # Converte o tipo da imagem cv2 para PIL
img = resizeimage.resize_contain(img, [770, 400]) # Redimensiona a imagem original para o tamanho especificado
tkimage = ImageTk.PhotoImage(img)
myvar=Label(mGui,image = tkimage)
myvar.image = tkimage
myvar.place(x=10,y=150) # Posiciona a imagem na janela
return
def Sift():
global meuAbrir
global img_transf # Variavel que recebe a imagem transformada para ser salva
img1 = cv2.imread(meuAbrir)
gray= cv2.cvtColor(img1,cv2.COLOR_BGR2GRAY) # Converte para escala de cinza
sift = cv2.xfeatures2d.SIFT_create() # Cria objeto SIFT
kp, des = sift.detectAndCompute(gray,None) # Localiza diretamente keypoints e descritores
img1=cv2.drawKeypoints(img1, kp, None, flags=0) # Desenha os keypoints sem orientacao do gradiente
img_transf = img1 # Recebe a imagem transformada
mlabel4 = Label(mGui,text=' ').place(x=270,y=40) # Limpa o label antes de imprimir os keypoints
mlabel4 = Label(mGui,text=len(kp)).place(x=270,y=40) # Imprime a quantidade de keypoints encontrados
img1 = cv2.cvtColor(img1,cv2.COLOR_BGR2RGB) # Converte o tipo da imagem BGR para RGB
img2 = Image.fromarray(img1) # Converte o tipo da imagem cv2 para PIL
img2 = resizeimage.resize_contain(img2, [770, 400]) # Redimensiona a imagem original para o tamanho especificado
tkimage = ImageTk.PhotoImage(img2)
myvar=Label(mGui,image = tkimage)
myvar.image = tkimage
myvar.place(x=10,y=150) # Posiciona a imagem na janela
return
def Surf():
global meuAbrir
global img_transf # Variavel que recebe a imagem transformada para ser salva
img1 = cv2.imread(meuAbrir)
gray = cv2.cvtColor(img1,cv2.COLOR_BGR2GRAY) # Converte para escala de cinza
surf = cv2.xfeatures2d.SURF_create(hessianThreshold=500, upright=False, extended=False) # Cria objeto SURF com threshold definido
keypoints, descriptor = surf.detectAndCompute(gray, None) # Localiza diretamente keypoints e descritores
#surf.setHessianThreshold(500) # Este parâmetro pode ser alterado
img1 = cv2.drawKeypoints(img1, keypoints, None, flags=0) # Desenha os keypoints sem orientacao do gradiente
img_transf = img1 # Recebe a imagem transformada
mlabel4 = Label(mGui,text=' ').place(x=270,y=40) # Limpa o label antes de imprimir os keypoints
mlabel4 = Label(mGui,text=len(keypoints)).place(x=270,y=40) # Imprime a quantidade de keypoints encontrados
img1 = cv2.cvtColor(img1,cv2.COLOR_BGR2RGB) # Converte o tipo da imagem BGR para RGB
img2 = Image.fromarray(img1) # Converte o tipo da imagem cv2 para PIL
img2 = resizeimage.resize_contain(img2, [770, 400]) # Redimensiona a imagem original para o tamanho especificado
tkimage = ImageTk.PhotoImage(img2)
myvar=Label(mGui,image = tkimage)
myvar.image = tkimage
myvar.place(x=10,y=150) # Posiciona a imagem na janela
return
def Fast():
global meuAbrir
global img_transf # Variavel que recebe a imagem transformada para ser salva
img1 = cv2.imread(meuAbrir) # Abre a imagem em escala de cinza: (meuAbrir,0)
# Initiate FAST object with default values
fast = cv2.FastFeatureDetector_create(threshold=25, nonmaxSuppression=1) # Define limiar para threshold e habilita supressao de nao maximos
kp = fast.detect(img1,None) # Procura e desenha os keypoints
img1 = cv2.drawKeypoints(image=img1, outImage=img1, keypoints = kp, flags = 4, color = (255,0,0))
img_transf = img1 # Recebe a imagem transformada
# Print all default params
#print "Threshold: ", fast.getInt('threshold')
#print "nonmaxSuppression: ", fast.getBool('nonmaxSuppression')
#print "neighborhood: ", fast.getInt('type')
#print "Total Keypoints with nonmaxSuppression: ", len(kp)
mlabel4 = Label(mGui,text=' ').place(x=270,y=40) # Limpa o label antes de imprimir os keypoints
mlabel4 = Label(mGui,text=len(kp)).place(x=270,y=40) # Imprime a quantidade de keypoints encontrados
img1 = cv2.cvtColor(img1,cv2.COLOR_BGR2RGB) # Converte o tipo da imagem BGR para RGB
img2 = Image.fromarray(img1) # Converte o tipo da imagem cv2 para PIL
img2 = resizeimage.resize_contain(img2, [770, 400]) # Redimensiona a imagem original para o tamanho especificado
tkimage = ImageTk.PhotoImage(img2)
myvar=Label(mGui,image = tkimage)
myvar.image = tkimage
myvar.place(x=10,y=150) # Posiciona a imagem na janela
return
def Orb():
global meuAbrir
global img_transf # Variável que recebe a imagem transformada para ser salva
img1 = cv2.imread(meuAbrir)
orb = cv2.ORB_create() # Cria objeto ORB
# find the keypoints with ORB
kp = orb.detect(img1,None)
# compute the descriptors with ORB
kp, des = orb.compute(img1, kp)
# draw only keypoints location, not size and orientation
img1 = cv2.drawKeypoints(img1, kp, None, color=(0,255,0), flags=0)
img_transf = img1 # Recebe a imagem transformada
mlabel4 = Label(mGui,text=' ').place(x=315,y=45) # Limpa o label antes de imprimir os keypoints
mlabel4 = Label(mGui,text=len(kp)).place(x=270,y=40) # Imprime a quantidade de keypoints encontrados
img1 = cv2.cvtColor(img1,cv2.COLOR_BGR2RGB) # Converte o tipo da imagem BGR para RGB
img2 = Image.fromarray(img1) # Converte o tipo da imagem cv2 para PIL
img2 = resizeimage.resize_contain(img2, [770, 400]) # Redimensiona a imagem original para o tamanho especificado
tkimage = ImageTk.PhotoImage(img2)
myvar=Label(mGui,image = tkimage)
myvar.image = tkimage
myvar.place(x=10,y=150) # Posiciona a imagem na janela
return
def mAbrirImagem():
global meuAbrir
meuAbrir = tkFileDialog.askopenfilename(initialdir = "../data",title = "Abrir Arquivo",filetypes=[("Arquivo de Imagem",'.bmp .png .jpg .jpeg .tif .tiff .DNG')]) # Abre o arquivo de imagem
path1.set(meuAbrir) # Mostra o caminho do arquivo de imagem
img1 = Image.open(meuAbrir) # Recebe a imagem selecionada pelo usuário
img1 = resizeimage.resize_contain(img1, [770, 400]) # Redimensiona a imagem original para o tamanho especificado
tkimage = ImageTk.PhotoImage(img1)
myvar=Label(mGui,image = tkimage)
myvar.image = tkimage
myvar.place(x=10,y=150)
return (meuAbrir)
def mSalvarTransformacao():
global img_transf
myFormats = [('Windows Bitmap','*.bmp'),\
('Portable Network Graphics','*.png'),\
('Tagged Image File Format','*.tiff'),\
('JPEG / JFIF','*.jpg'),('CompuServer GIF','*.gif'),]
filename = tkFileDialog.asksaveasfilename(initialdir = "../data",title = "Selecionar Arquivo",filetypes=myFormats)
cv2.imwrite(filename,img_transf)
tkMessageBox.showinfo(title="Salvar Transformação",message="Arquivo gravado com sucesso!")
def mSobre(): # Mostra a caixa de diálogo Sobre
tkMessageBox.showinfo(title="Sobre",message="Autor: Everton Castelão Tetila\nSoftware: Template Matching\nVersão: 1.0 ")
return
def mFechar():
meuFechar = tkMessageBox.askyesno(title="Fechar",message="Deseja sair?") # Mostra a caixa de diálogo Fechar
if meuFechar > 0: # Não=0; Sim>0
mGui.destroy() # Encerra o programa
return
# Construção de LabelFrame com Radiobuttons para a seleção do descritor local
group1 = LabelFrame(mGui, text="Descritores Locais") # Cria um LabelFrame para organizar os Radiobuttons
group1.pack(anchor="nw", padx=12, pady=13) # Alinha o LabelFrame superior a esquerda (nw)
mlabel1 = group1 # Cria o texto no label1
Radio_1=Radiobutton(group1,text="SIFT",variable=opcao,value = 1)
Radio_2=Radiobutton(group1,text="SURF",variable=opcao,value = 2)
Radio_3=Radiobutton(group1,text="FAST",variable=opcao,value = 3)
Radio_4=Radiobutton(group1,text="ORB",variable=opcao,value = 4)
mlabel1.pack(side="top")
Radio_1.pack(anchor=W)
Radio_2.pack(anchor=W)
Radio_3.pack(anchor=W)
Radio_4.pack(anchor=W)
# Construção do Entry para mostrar o caminho da imagem
mlabel2 = Label(mGui,text='Escolha a imagem:').place(x=200,y=18) # Cria o texto no label2
mEntry1 = Entry(mGui,width=25, textvariable=path1).place(x=320,y=15) # Componente mEntry1 para receber o caminho da imagem
mbutton1 = Button(mGui,text='...',command = mAbrirImagem, height=1).place(x=528,y=10)
mlabel3 = Label(mGui,text='Keypoints: ').place(x=200,y=40) # Cria o texto no label2