Relatorio TP2

Trabalho prático nº 2: Scikit-image e OpenCV
Licenciatura em Engenharia Informática

Multimédia e Computação Gráfica 2022/2023
Trabalho Prático nº 2
Scikit-image e OpenCV
Realizado em: 20/11/2022

Elaborado em: 18/11/2022
Raul Marian Aconstantinesei
Multimédia e Computação Gráfica 2022/2023 Pág. 1 de 33

Índice
1. Introdução ............................................................................................................. 4
1.1. Requisitos e tutoriais .................................................................................... 5
1.1.1. OpenCV [1] .................................................................................................. 5
1.1.2. Scikit-image [2] ........................................................................................... 5
2. Métodos.................................................................................................................. 5
2.1. Understanding the basics of gray image processing ............................... 5
2.2. Understanding the basics of color image processing .............................. 7
2.3. Understanding the basics of image transformations .............................. 9
2.4. Scikit-image .................................................................................................. 10
2.5. OpenCV - Licence Plate ............................................................................. 12
2.6. OpenCV - Pokemons .................................................................................. 13
2.7. Menus............................................................................................................. 15
2.7.1. Menu Inicial ............................................................................................... 15
2.7.2. Menu Exercicio 1 ...................................................................................... 15
2.7.3. Menu Exercicio 2 ...................................................................................... 15
2.7.4. Menu Exercicio 3 ...................................................................................... 15
2.7.5. Menu Exercicio 4 ...................................................................................... 16
2.7.6. Menu Exercicio 5 ...................................................................................... 16
2.7.7. Menu Exercicio 6 ...................................................................................... 16
2.7.8. Menu Pokemons ....................................................................................... 16
3. Resultados............................................................................................................ 17
3.1. Understanding the basics of gray image processing.............................. 17
3.1.a. Show the algoritm .................................................................................... 17
3.1.b. Test the function color2gray(color)...................................................... 18
3.1.d. Test the function image2gray(file path) ............................................... 19
3.2. Understanding the basics of color image processing ............................ 20
3.2.a. Show the average RGB from image...................................................... 20
3.2.b. Get and update a pixel from the image ............................................... 21
3.2.c. Show the location of the pixel with higher values .............................. 22
3.3. Understanding the basics of image transformations ............................ 23
3.3.a. Rotate image 90 degrees clockwise ...................................................... 23
3.3.b. Rescale image to one quarter of its size .............................................. 23
3.4. Scikit-image .................................................................................................. 24
3.4.a. Change background to an color............................................................. 25
3.4.b. Resize or Rescale image .......................................................................... 25
3.4.b.1. Resize ...................................................................................................... 25
3.4.b.2. Rescale .................................................................................................... 26
3.4.c. Rotate the image ...................................................................................... 26
3.4.d. Flip the image ........................................................................................... 27
3.4.d.1. Horizontaly ............................................................................................ 27
3.4.d.2. Vertically................................................................................................. 28
3.4.e. Crop the image ......................................................................................... 28
3.5. OpenCV-Licence Plate ............................................................................... 29
3.6. OpenCV-Pokemon ...................................................................................... 29
3.6.a. Recognize pokemons in a static image ................................................. 30
3.6.a.1/4. Charmander,Pikachu,Bulbasaur,Squirtle ...................................... 30
3.6.a.5. All pokemons ......................................................................................... 31

3.6.a. Recognize pokemons in real-time images ........................................... 31

3.7. Exit ................................................................................................................. 31
4. Discussão.............................................................................................................. 32
5. Conclusão ............................................................................................................ 32
Referências............................................................................................................... 33

1. Introdução
Como segundo trabalho pratico este consiste em desenvolver 6 mini programa que
implicam os novos metodos lecionados nas aulas.
O primeiro exercicio consiste na transformacao de cores RGB para uma escala de
cinzento correspondente a cor respetiva. A escala de cinzento pode ser obtida atraves da
formula fornecida no enunciado que diz o seguinte: escala de cinzento = 0.2126 * vermelho
+ 0.7152*verde+0.0722*azul, em que R,G,B corresponde a vermelho,verde,azul
respetivamente. Após se conseguir obter as escalas de cinzento das cores será nescessario
utilizar o mesmo metodo para desta vez passar uma imagem para preto e branco, isto tudo sem
utilizar as bibliotecas já existentes de processamento de imagens.
O segundo exercicio consiste em obter e alterar dados de determinadas imagens.Como
primeiro pedido é nescessario obter o “RGB medio” de uma imagem introduzida pelo utilizador.
De seguida é nescessario poder obter os valores de RGB de um determinado pixel introduzido
pelo utilizador e de seguida alterar os seus valores para novos valores introduzidos pelo
utilizador. Por deve-se conseguir encontrar e mostrar ao utilizador o pixel com os valores RGB
mais altos de uma imagem introduzida por ele.
O terceiro exercicio esta dividido em 2 sub-programas em que o primeiro consiste em
rodar uma imagem 90º em sentido horario. O segundo sub-programa consiste em dar “rescale”
a uma imagem para 1/4 do tamanho original. Ambos os programas devem ser realizados sem o
auxilio das bibliotecas Scikit-image e OpenCV.
No quarto deverá ser possivel efetuar varias alteracoes a uma imagem, desta vez ja se
pode recorrer as bibliotecas já existentes. Deve ser possivel mudar a cor do fundo de fundo
(imagem com fundo branco) para uma cor inserida pelo utilizador. Este exercicio terá varias
formas de alterar a imagem tais como:
• Alterar o tamanho da imagem
• Rodar a imagem
• Cortar a imagem
• Aplicar diversos filtros
• Inverter a imagem
Apos serem aplicadas as alteraçoes desejadas deve ser mostrada a imagem original e a imagem
alterada lado a lado, permitindo assim confirmar as mudanças.
No quinto exercicio é nescessario identificar uma matricula inserida pelo o utilizador e
extrair o numero da matricula. Apos se lero numero da matricula deve ser mostrada a matricula
devidamente selecionada e com o seu numero impresso por cima.
Por fim, o ultimo exercicio é sobre algo que animou a infancia a muitas crianças. Esse
algo são os Pokemons. Sendo assim, este exercicio vai unir os pokemons com a reciclagem de
tampas, isto é vai identificar diferentes pokemons dependendo da cor da tampa encontrada. Para
isso o a primeira parte do programa deve conseguir identificar circulos de uma determinada cor
em uma imagem inserida pelo utilizador e substituir o circulo pelo respetivo pokemon. Deve
tambem contar quantos circulos, da respetiva cor, existem na imagem. Apos ter reconhecido os
pokemons numa imagem estatica passamos assim para o ultimo passo, o reconhecimento video.
Deve assim por fim permitir reconhecer os pokemons presentes nas imagens em tempo
real da camera do dispositivo.

1.1. Requisitos e tutoriais

Para poder executar/testar o programa terá que instalar várias bibliotecas. De seguida
irão estar os passos a seguir para instalar cada biblioteca nescessaria. Deverá ter instalado o
Python em seu computador.
1.1.1. OpenCV (opencv-python)

Para instalar esta biblioteca terá que abrir a linha de comandos e executar a seguinte
linha:
Pip install opencv-python
Apos pressionar ENTER a instalaçao da biblioteca irá comecar e apos a instalaçao poderá
verificar a sua instalação atraves do python ao inserir:
import cv2
1.1.2. Scikit-image (scikit-image)

Para instalar esta biblioteca terá abrir a linha de comandos e executar a seguinte linha:
Pip install scikit-image
Apos ter finalizado a instalação da biblioteca pode verificar ao escrever:
from skimage import *
1.1.2. Pytesseract (Hoffstaetter)

Para instalar esta biblioteca terá abrir a linha de comandos e executar a seguinte linha:
pip install pytesseract
Caso o metodo acima nao funcione deverá baixar o executavel e adicionar a localizaçao
do pytesseract ao codigo.
2. Métodos
De seguida será documentado o desenvolvimento de cada exercicio.
2.1. Understanding the basics of gray image processing

Para uma melhor organizaçao decidi criar os exercicos alinea a alinea.
Comecei entao por mostrar a equaçao que permite calcular a escala de cinzento da cor
def showalgorithm():
print("luminance = 0.2126 * red + 0.7152*green+0.0722*blue")
De seguida prosegui a criar a funcao color2gray() que ira receber como parametro uma cor e
irá devolver a escala de cinzento da cor introduzida.
def color2gray(color):
return 0.2126 * color[0] + 0.7152 * color[1] + 0.0722 * color[2]

Para chamar esta funçao é nescessario pedir pedir ao utilizador os valores RGB da cor que
pretende converter.
R = int(input("R value:"))
G = int(input("G value:"))
B = int(input("B value:"))
color = (R,G,B)
gray_color = Funcoes.color2gray(color)
print(f"The shade of gray of RGB{color} is: {int(gray_color)}")
Funcoes.show_image_color(gray_color)
input("Press enter to continue ...")
Apos ter criado a funçao posso assim proceder ao primeiro uso dela que consiste em calcular a
escala de cinzento da cor RGB(154,50,20).
color = (154,50,20)
gray_color = Funcoes.color2gray(color)
print(f"The shade of gray of RGB{color} is: {int(gray_color)}")
De seguida, para uma melhor interpertaçao do utilizador mostro uma imagem de 200x200 com
a cor recebida.
Funcoes.show_image_color(gray_color)
input("Press enter to continue ...2")
A funcao show_image_color() recebe como parametro uma cor (R,G,B) e cria uma imagem
com esses valores para todos os pixeis. Por fim mostra um grafico com essa imagem.
def show_image_color(color):
image = np.zeros((200,200,3), dtype=np.uint8)
image[:,:] = color
plt.imshow(image)
plt.show()
Apos se verificar que a funçao faz o presuposto, podemos agora adaptar uma funcao que utiliza
a funcao color2rgb() para passar uma imagem para escala de cinzento.
def img2gray(file):
img = imread(file)
colors = (img[:,:,0],img[:,:,1],img[:,:,2])
gray = color2gray(colors)
plt.imshow(gray,cmap = 'gray')
plt.show()
Esta funçao recebe como parametro o camihno para a imagem. Apos abrir a imagem guarda as
cores de todos os pixeis no tuple cores. Este tuple é enviado para a funcao color2gray() que
vai transformar todos os valores nele contidos para escla de cinzento. De seguida é mostrada a
imagem em escala de cinzentos.

Para executar esta funcao é nescessario pedir ao utilizador apenas o caminho da imagem
file = input("Please insert the image path: ")

Funcoes.img2gray(file)
2.2. Understanding the basics of color image processing

Para calcular o “RGB medio” crio uma variavel que vai guardar todos os valores rgb da
imagem em uma linha vertical. Isto vai permitir utilizar a funçao np.average para calcular os
valores da cor media. Por fim mostro a cor recebida atraves da funçao show_image_color()
def showavg(file):
img = imread(file)
im = np.array(img)
w,h,d = img.shape
im.shape = (w*h, d)
average_color = np.average(im, axis=0)
print(f"The average color for your image is:
{int(average_color[0]),int(average_color[1]),int(average_color[2])}")
show_image_color(average_color)
Para chamar esta funçao apenas é nescessario pedir o caminho da imagem que se pretende
utilizar.

Funcoes.showavg(file)
De seguida desenvolvi uma outra funçao que consegue obter o pixel solicitado pelo utilizador.
Esta funcao vai receber como parametros o caminho da imagem e a posicao (x,y) do pixel
desejado.

x = int(input("X value: "))
y = int(input("Y value: "))
Funcoes.getpixel(file,x,y)
Funcoes.changepixel(file,x,y)
Apos se ter o nescessario pede-se entao chamar a funcao.
def getpixel(file,x,y):
img = imread(file)
print(f"The RGB values for that pixels are: {img[y][x]}")
show_image_color(img[y][x])

Apos se mostrar os valores do pixel pode-se entao proceder á sua alteraçao. Para isso são
pedidios os valores RGB da cor para a qual pretende trocar o pixel.
def changepixel(file,x,y):
img = imread(file)
img[y][x][0] = input("Value off R:")
img[y][x][1] = input("Value off G:")
img[y][x][2] = input("Value off B:")
plt.imshow(img)
plt.show()
Apos se alterar os valores do pixel é mostrada a imagem para permitir a confirmaçao da

alteraçao.
Por fim é nescessario mostrar o pixel com os valores (RGB) mais elevados. Para isso percorro
toda a imagem e verifico qual a soma dos valores (RGB) de cada pixel guradando assim as
coordenadas do pixel com a maior soma. Apos se ter as coordenadas do pixel decidi evidenciar
o pixel em questao inserindo um circulo e um quadrado á volta do pixel, como uma mira. Por
fim mostro a imagem com a cor na mira.
def higherrgb(file):
img = imread(file)
h,w = img.shape[:2]
soma_cores=0
for y in range(h):
for x in range(w):
if soma_cores <
int(img[y][x][0])+int(img[y][x][1])+int(img[y][x][2]):
soma_cores =
int(img[y][x][0])+int(img[y][x][1])+int(img[y][x][2])
max_x=x
max_y=y
cv2.circle(img, (max_x,max_y), 2, 1)
cv2.rectangle(img, (max_x-10, max_y+10), (max_x+10, max_y-10), 1)
print(f"The pixel with the highest RGB vale is {(max_y,max_x)} as R =
{img[max_y][max_x][0]},G = {img[max_y][max_x][1]} and B =
{img[max_y][max_x][2]} ")
plt.imshow(img)
plt.show()
Para se executar esta funcao apenas é nescessario pedir o caminho da imagem.

Funcoes.higherrgb(file)

2.3. Understanding the basics of image transformations

Para este exercicio é nescessario criar uma funcao que possibilita a rotação a 90º de
uma imagem inserida pelo utilizador. Para isso decidi obter a altura e a largura da imagem e
copiar os pixeis de x para y de forma que a imagem final estivesse rodada.
def rotate90(img):
h,w = img.shape[:2]
rotate_img = np.zeros([w,h,3],np.uint8)
for y in range(h):
for x in range(w):
rotate_img[x,y]=img[h-y-1,x]
return rotate_img
Esta funcao recebe como parametro uma imagem que deve ser anteriormente pedida
ao utilizador.
image = Funcoes.imread(file)
rotated_image = Funcoes.rotate90(image)
Por fim é mostrada a imagem rodada.

Funcoes.plt.imshow(rotated_image)
Funcoes.plt.show()
De seguida para redimensionar uma imagem para 1/4 do tamanho original é nescessario
obter a altura e a largura da imagem original e, a partir desses dados, criar uma imagem nova
que terá a altura/4 e a largura/4 da imagem original. Apos se ter criado a imagem passo a copiar
os pixeis para a nova imagem em que cada pixel da imagem original vai equivaler a 0.25 do pixel
da imagem redimensionada, isto é, cada pixel da imagem redimensionada equivale a 4 pixeis da
imagem original.
def my_rescale(img):
w,h = img.shape[:2]
xNew = int(w / 4)
yNew = int(h / 4)
Rescaled = np.zeros([xNew, yNew,3],np.uint8)
for i in range(xNew):
for j in range(yNew):
Rescaled[i, j]= img[int(i * 4),int(j * 4)]
return Rescaled
Esta funçao recebe como parametro uma imagem e retorna uma imagem que de seguida
é mostrada ao utilizador .
image = Funcoes.imread(file)
Rescaled_image = Funcoes.my_rescale(image)
Funcoes.plt.imshow(Rescaled_image)
Funcoes.plt.show()

2.4. Scikit-image
Este exercicio é construido com varias funcoes que possibilitam modificar a imagem
original. Criei assim tambem uma funcao que mostra a imagem no estado inicial e a imagem no
estado atual com todas as modificaçoes realizadas ate ao momento.
def show_original_new(new_image,image):
plt.subplot(121)
plt.imshow(image)
plt.title("Original image")
plt.subplot(122)
plt.imshow(new_image)
plt.title("Final Image")
plt.show()
Esta funçao recebe a imagem original e a imagem atual e mostra-as lado a lado para
permitir verificar as alteraçoes realizadas.
Começando entao pelas funcoes que alteram a imagem temos assim a funcao
changebackground() que vai receber uma imagem e alterar todos os pixeis de cor branca
(valores superiores a RGB(240,240,240)) e alteralos para a cor que o utilizador pretender. Para
uma melhor organizaçao esta cor é solicitada logo no inicio da funcao. Esta funcao apenas pode
ser usada uma vez ja que apos trocar o fundo ja não irão existir pixeis brancos que possam ser
alterados.
def changebackground(image):
print("Insert the values for the background color")
R=input("R:")
G=input("G:")
B=input("B:")
print("Changing Background ...")
h,w = image.shape[:2]
for i in range(h):
for j in range(w):
if image[i][j][0]>240 and image[i][j][1]>240 and
image[i][j][2]>240:
image[i][j][0] = R
image[i][j][1] = G
image[i][j][2] = B
print("Background Successfully Changed ")
image = cv2.medianBlur(image,5)
return image

De seguida temos a funcao resize_image() que vais receber uma imagem e redimensionala.
Para redimensionar uma imagem temos 2 opcoes :
1. Resize
2. Rescale
Sendo assim o utilizador é questionado sobre o metodo que pretente utilizar logo no inicio da
funçao.
def resize_image(image):
option = int(input("Chose the option:\
\n1.Resize\
\n2.Rescale\
\nOption:"))
Caso o utilizador escolha dar resize na imagem terá que introduzir a nova altura e a nova largura
da imagem.
if option == 1:
image = resize(image,(int(input("Please insert the new
height:")),int(input("Please insert the new weight:"))))
return image
Caso o utilizador escolha dar Rescale na imagem terá que introduzir apenas a escala que pretente
usar.
elif option == 2:
image = rescale(image,float(input("Please insert the scale yo
use:")),channel_axis=2)
return image
De seguida temos a funçao flip_image() que vai receber uma imagem e assim como o nome
indica vai vira-la no eixo do x ou no eixo do y.
def flip_image(image):
option = int(input("Chose the option:\
\n1.Horizontally\
\n2.Vertically\
\nOption:"))
if option == 1:
return flipud(image)
elif option == 2:
return fliplr(image)
Outra funcao é a rotate_image() que irá receber uma imagem e pedir ao utilizador o angulo
que pretende rodar a imagem.
def rotate_image(image):
return rotate(image, angle=int(input("Insert the angle to rotate:")))

Por fim temos a funçao crop_image() que vai receber uma imagem e pedir ao utilizador os
pontos de inicio e os pontos de fim que pretende utilizar.
def crop_image(image):
return image[int(input("Start x:")):int(input("End
x:")),int(input("Start y:")):int(input("End y:"))]
Todas estas funcoes sao executadas apenas quando o utilizador se encontra no menu do
exercicio 4 e escolhe a funçao. É assim executada a funcao escolhida e de seguida é mostrado
lado a lado a imagem original e a imagem com a alteraçao realizada.
image = Funcao escolhida pelo utilizador

Funcoes.show_original_new(image,Funcoes.imread(file))
2.5. OpenCV - Licence Plate

Neste exercicio foi nescessario aplicar o que lecionamos nas ultimas aula de
processamento de imagens para ler uma matricula e ao mesmo tempo rodear/selecionar a
matricula de uma imagem. Para isso utilizei a funcao pytesseract.image_to_data() que recebe
uma imagem e busca texto devolvendo assim tambem a posiçao do texto. Isto permite criar um
retangulo á volta da matricula utilizando a posição do texto mais a esquerda e do topo o que
adicionando o tamanho do texto vai criar um retangulo com a altura e a largura da matricula
identificada.
def readplate(image):
rgb = cv2.cvtColor(image,cv2.COLOR_BGR2RGB)
rgb = cv2.medianBlur(rgb,1)
results = pytesseract.image_to_data(rgb, output_type=Output.DICT)
for i in range(len(results["text"])):
x = results["left"][i]
y = results["top"][i]
w = results["width"][i]
h = results["height"][i]
cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
De seguida passo a imagem para o esquema de cores HSV para cria de seguida uma mascara que
vai identificar apenas a cor preta, que neste caso será o numero da matricula, e ignorar o
resto.Apos ter criado a mascara, com o auxilio dos pontos do retangul separo apenas os
numeros da matricula e de seguida desfoco a imagem para facilitar o reconhecimento do texto.
Por fim removo o (\n\f) que existe no fim da leitura de texto para um melhor aspeto ao mostrar
a imagem.
hsv = cv2.cvtColor(image,cv2.COLOR_BGR2HSV)
lower_bound = np.array([0,0,0])
upper_bound = np.array([50,50,50])
mask = cv2.inRange(hsv,lower_bound,upper_bound)
matricula = mask[y:y+h,x:x+w]
matricula = cv2.medianBlur(matricula,15)
text = pytesseract.image_to_string(matricula,config="--psm
6",lang="eng")

text = text.replace('\n\f','')
cv2.putText(image, text, (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX,
0.5, (0, 0, 200), 2, cv2.LINE_AA)
print(f"The license plate is:{text}")
plt.imshow(image)
plt.show()
Esta função recebe como parametros apenas a imagem da matrícula.
2.6. OpenCV - Pokemons

Por fim chegamos ao exercício dos Pokémons. Aqui serão identificados Pokémons em
imagens introduzidas pelo utilizador. A função imagepokemon() recebe uma imagem e o
índice do Pokémon a ser mostrado. Primeiramente passo a imagem para escala de cinzentos e
desfoco-a para poder identificar os círculos mais facilmente. De seguida passo a imagem para
HSV o que vai permitir um maior controlo sobre os intervalos de cor de cada Pokémon.
def imagepokemon(image,n_pokemon):
circles = 0
gray = cv2.cvtColor(image,cv2.COLOR_RGB2GRAY)
gray = cv2.medianBlur(gray,9)
hsv=cv2.cvtColor(image,cv2.COLOR_BGR2HSV)
hsv = cv2.medianBlur(hsv,5)
circle = cv2.HoughCircles(image =
gray,method=cv2.HOUGH_GRADIENT,dp=1.5,minDist=80,param1=110,param2=70,max
Radius=80)
Apos identificar todos os círculos presentes na imagem, caso existam círculos, vou
percorrer o array de círculos e buscar as coordenadas do centro e o raio de cada círculo.
Através de esses dados posso assim descobrir qual a cor do círculo (assumo a cor do centro).
De seguida dependendo do Pokémon que o utilizador escolheu será ou não mostrado o
Pokémon com a cor do círculo atual. Apos ter verificado qual o Pokémon que corresponde ao
círculo atual, a imagem do Pokémon é redimensionada para o diâmetro do circulo e por fim
inserido na imagem.
if circle is not None:

circle = np.uint16(np.around(circle))
for co,i in enumerate(circle[0,:],start = 0):
if(i[0]<len(image[0]) and i[1]<len(image)):
cores = hsv[i[1],i[0]]
if n_pokemon == 1 or n_pokemon == 5:
pokemon = chosecharmander(cores)
if n_pokemon == 2 or n_pokemon == 5 and pokemon is
None:
pokemon = chosepikachu(cores)
None:
pokemon = chosebulbasaur(cores)
None:

pokemon = chosesquirtle(cores)
if pokemon is not None:
circles +=1
resize =
cv2.resize(pokemon,(i[2]*2,i[2]*2),interpolation = cv2.INTER_AREA)
image[i[1]-i[2]:i[1]+i[2],i[0]-i[2]:i[0]+i[2]]=resize
# cv2.circle(image,(i[0],i[1]),i[2],(0,255,0),3)
Por fim escrevo no canto da imagem qual a quantidade de Pokémons da cor escolhida existem
na imagem e mostro a imagem com os Pokémons escolhidos substituídos.
if n_pokemon != 5:
cv2.putText(image, pokemons[n_pokemon-1]+str(circles), (10,30),
cv2.FONT_HERSHEY_SIMPLEX,
1, text_color[n_pokemon-1], 2, cv2.LINE_AA)
cv2.imshow('Pokemons',image)
Na alínea a) é necessário enviar apenas uma imagem inserida pelo utilizador.

image = Funcoes.cv2.imread(file)
n_pokemon = Funcoes.chosepokemon()
Funcoes.imagepokemon(image,n_pokemon)
cv2.waitKey(0)
Na alínea c) é nescessario reconhecer os pokemons em imagens em tempo real o que apenas

implica enviar cada imagem para a função imagepokemon() e automaticamente ira mostrar os
pokemons na imagem da camera. Como o programa demora uns segundos a iniciar o
VideoCapture() decidi avisar o utilizador que deve esperar através do “loading…”. Para parar
o programa o utilizador deve pressionar a tecla S.
print("b.\nLoading...")
cam=cv2.VideoCapture(0)
vid = cv2.VideoCapture(0)
n_pokemon = Funcoes.chosepokemon()
print("Press s key to stop")
while(True):
ret,image = vid.read()
Funcoes.imagepokemon(image,n_pokemon)
if cv2.waitKey(1)&0xFF == ord('s'):
break
vid.release()
cv2.destroyAllWindows()
return cores

2.7. Menus
Para uma melhor organização decidi criar uma funçao para cada menu.
Qualquer escolha que esteja fora dos parametros do programa será avisada ao ser
introduzida.
2.7.1. Menu Inicial

Este é o menu que aparece quando se executa o programa e permite escolher qual o
exercício que deseja executar.
def menu_inicial():
return int(input("Choose the exercise you want to perform\
\n1. Understanding the basics of gray image processing\
\n2. Understanding the basics of color image processing\
\n3. Understanding the basics of image transformations\
\n4. Scikit-image\
\n5. OpenCV-Licence Plate\
\n6. OpenCV-Pokemon\
\n7. Exit\
\nExercise:"))
2.7.2. Menu Exercicio 1

def menu_1():
return input("Choose the exercise you want to perform\
\na) Show the algoritm\
\nb) Test the function color2gray(color)\
\nc) Show the shade of gray of RGB(154,50,20)\
\nd) Test the function image2gray(file path)\
\ne) Exit\
\nExercise:")

def menu_2():
\na) Show the average RGB from image\
\nb) Get and update a pixel from the image\
\nc) Show the location of the pixel with higher values\
\nd) Exit\
\nExercise:")

def menu_3():
\na) Rotate image 90 degrees clockwise\
\nb) Rescale image to one quarter of its size\
\nc) Exit\
\nExercise:")


def menu_4():
\na) Change background to an color\
\nb) Resize or Rescale image\
\nc) Rotate the image\
\nd) Flip the image\
\ne) Crop the image\
\nf) Exit\
\nExercise:")

def menu_5():
\na) Read licence plate\
\nb) Resize or Rescale image\
\nc) Rotate the image\
\nd) Flip the image\
\ne) Crop the image\
\nf) Exit\
\nExercise:")

def menu_6():
\na) Recognize pokemons in a static image\
\nb) Recognize pokemons in real-time images\
\nc) Exit\
\nExercise:")
2.7.8. Menu Pokemons
def chosepokemon():
return int(input("Chose the pokemon to be shown:\
\n1.Charmander\
\n2.Pikachu\
\n3.Bulbasaur\
\n4.Squirtle\
\n5.All pokemons\
\nOption:"))

3. Resultados
Aqui pode confirmar os outputs de cada exercicio/alinea
Ao executar o programa ira ver o Menu inicial onde poderá escolher o exercicio que
quer executar.
Output 1: Menu Inicial
3.1. Understanding the basics of gray image processing

Ao escolher a opção 1 ser-lhe-a mostrado o menu do exercicio 1 em que podera
escolher a alinea que deseja executar.
Output 2: Exercicio 1 Menu
3.1.a. Show the algoritm

Ao escolher a opçao a) ser-lhe-a mostrado o algoritmo usado para calcular escala de
cinzento das cores.
Output 3: Algoritmo

3.1.b. Test the function color2gray(color)

Ao escolher a opçao b) ser-lhe-a pedida a cor RGB que pretende utilizar.
Output 4:Input alinea b)
De seguida será mostrado o resultado.
Output 5: Escala de cinzento da cor RGB (133,200,230)
Seguido da exibição de uma imagem com a cor respetiva.
Gráfico 1: Escala de cinzento da cor RGB (133,200,230)
3.1.c. Show the shade of gray of RGB(154,50,20)

Ao escolher a opçao c) ser-lhe-á mostrada a escala de cinza da cor RGB(154,50,20).
Output 6: Escala de cinzento da cor RGB (154,50,20)

Seguido da exibição de uma imagem com a cor respetiva.
Gráfico 2 :Escala de cinzento da cor RGB (154,50,20)
Para continuar terá de fechar o gráfico através do X do canto ou pressionando a tecla “Q”.
3.1.d. Test the function image2gray(file path)

Ao escolher a opção d). ser-lhe-á pedido o caminho da imagem que pretende utilizar.
Output 7: Input Alinea d)
Ira de seguida ser mostrada a imagem em escala de cinzentos.
Grafico 3:Imagem papagaio.jpg em escala de cinzentos
Pode de seguida fechar o gráfico através do X do canto ou pressionando a tecla “Q”.

3.2. Understanding the basics of color image processing

Ao escolher a opção 2 ser-lhe-á mostrado o menu do exercício 2 em que poderá
escolher a alínea que deseja executar.
3.2.a. Show the average RGB from image

Ao escolher a opçao a) terá de introduzir o caminho da imagem que deseja utilizar.
Output 9: Input alinea a)
Ira de seguida ser mostrado o valor da cor media da imagem seguido de um gráfico com a cor
representada.
Output 10:Cor media da imagem papagaio.jpg
Grafico 4: Cor media da imagem papagaio.jpg

3.2.b. Get and update a pixel from the image

Ao escolher a opção b) terá de introduzir o caminho da imagem que deseja utilizar.
Output 11: Input alinea b)
De seguida terá de introduzir as coordenadas do pixel a que quer aceder.
Ser-lhe-ão assim mostrados os valores RGB do pixel introduzido.
Output 13:Valores RGB do pixel (400,500)
Gráfico 5:Cor (220,217,210)
De seguida são pedidos os valores RGB com quais pretende substituir o pixel selecionado.
Output 14:Input valores RGB alínea b)

Por fim será mostrada a imagem com o pixel atualizado.
Gráfico 6:Imagem cortada local da alteração do pixel

3.2.c. Show the location of the pixel with higher values
Ao escolher a opção c) terá de introduzir o caminho da imagem que deseja utilizar.
Output 15:Input alínea c)

Serão assim indicadas as coordenadas e o valor RGB do pixel com os valores mais elevados.
Output 16:Coordenadas e valores do pixel com os valores RGB mais elevados da imagem
papagaio.jpg
De seguida será mostrada a imagem com o pixel dentro de uma mira. A mira estará pequena
em imagens de grandes dimensões.
Gráfico 7:(imagem ampliada) pixel dentro da mira

3.3. Understanding the basics of image transformations

3.3.a. Rotate image 90 degrees clockwise

Ao escolher a opção a) terá de introduzir o caminho da imagem que deseja utilizar.
Output 18:Input alínea a)
A imagem será rodada 90º no sentido do relógio e será mostrado o resultado.
Gráfico 8:Imagem papagaio.jpg rodada 90º
3.3.b. Rescale image to one quarter of its size

Ao escolher a opção b) terá de introduzir o caminho da imagem que deseja utilizar.

A imagem será redimensionada e cada 4 pixels da imagem original irão equivaler a 1 pixel da
imagem redimensionada. O resultado será o seguinte:
Grafico 9:Imagem papagaio.jpg redimensionada para 1/4
3.4. Scikit-image
Ao escolher a opção 4 terá de introduzir o caminho da imagem que deseja utilizar.
Deverá utilizar uma imagem com fundo branco para melhores resultados.Todas as alíneas estão
seguidas logo as alterações são quanto a imagem presente na alinea anterior.
Output 20: Input Exercicio 4
Apos ter escolhido a imagem que será utilizada ser-lhe-a mostrado o menu do exercicio 4 onde
pode escolher quais alteraçoes deseja fazer á imagem.
Output 21:Menu exercicio 4

3.4.a. Change background to an color

Ao escolher a opçao a) terá que introduzir os valores RGB da cor que pretende utilizar para o
fundo da imagem.
Grafico 10: Exercicio 4 alinea a)
A imagem será mostrada lado a lado com a imagem original.
Grafico 11:Imagem com fundo vermelho
3.4.b. Resize or Rescale image

Ao escolher a opção b) terá de escolher se pretende dar rescale á imagem ou redimensioná-la
Output 22: Sub-menu alinea b)
3.4.b.1. Resize
Ao escolher a 1. terá que introduzir os novos tamanhos da imagem.
Output 23:Input altura nova e largura nova

Apos introduzir os dados pedidos será mostrada a imagem com os novos tamanhos.
Grafico 12:Imagem com fundo vermelho e tamanho alterado
3.4.b.2. Rescale
Ao escolher a 2. terá de introduzir a escala que pretende utilizar.
Output 24:Input escala
Apos introduzir uma escala valida será mostrada a imagem com os novos tamanhos.
Grafico 13:Imagem com fundo vermelho e tamanho em escala 0.5 em relação a alínea anterior
3.4.c. Rotate the image

Ao escolher a opçao c) terá de introduzir o angulo que pretende usar para rodar a
imagem.
Output 25: Input do angulo

Apos introduzir o angulo a imagem será rodada e de seguida exibida com as alterações realizadas.
Grafico 14:Imagem rodada 180º

3.4.d. Flip the image
Ao escolher a opçao c) deverá escolher se pretende inverter a imagem quanto ao eixo
do x ou quanto ao eixo do y.
Output 26: Sub-menu Alinea d)

3.4.d.1. Horizontaly
Ao escolher a opcao 1. a imagem será invertida quanto ao eixo do y.
Grafico 15:Imagem invertida horizontalmente

3.4.d.2. Vertically
Ao escolher a opcao 1. a imagem será invertida quanto ao eixo do x.
Grafico 16:Imagem invertida verticalmente
3.4.e. Crop the image

Ao escolher a opção e) terá que introduzir as coordenadas de início e fim da nova
imagem quanto á imagem original
Output 27: Input dados
Será entao mostrado o pedaco da imagem cortado.
Grafico 17:Imagem recortada.

3.5. OpenCV-Licence Plate

Ao escolher a opção 5 terá que introduzir o caminho da imagem da matrícula que
pretende usar.
Output 28: Input caminho imagem
Será entao reconhecida a matricula e mostrada terminal.
Output 29:Matrícula no terminal
Será também mostrada a matrícula selecionada e o seu devido número por cima da caixa.
Grafico 18:Matrícula no gráfico
3.6. OpenCV-Pokemon
Output 30:Menu exercicio 6

3.6.a. Recognize pokemons in a static image

Ao escolher a opção a) terá de introduzir o caminho da imagem da matrícula que
pretende usar.
Output 31: Input imagem circulos.jpg
Apos importar o ficheiro terá de escolher qual o Pokémon que quer identificar na imagem.
3.6.a.1/4. Charmander,Pikachu,Bulbasaur,Squirtle
Ao escolher uma opção de 1 a 4 ser-lhe-á apenas identificado o Pokémon em questão.
Grafico 19:Charmander Grafico 20: Pikachu
Grafico 21:Bulbasaur Grafico 22: Squirtle

3.6.a.5. All pokemons

Ao escolher uma opção 5 ser-lhe-ão mostrados todos os pokemons encontrados na imagem.
Grafico 23:All pokemons together
3.6.a. Recognize pokemons in real-time images

Ao escolher a opção b) terá que escolher da mesma maneira como na alínea a) o
Pokémons que quer identificar. De seguida encontra-se uma captura de um momento a
identificar os Pokémons num comando. E ao lado esta uma imagem do comando utilizado.
3.7. Exit
Ao escolher a opçao 7 tal como o nome indica irá sair do programa.

4. Discussão
Este trabalho pratico foi mais complicado que o anterior principalmente pelo facto de
em alguns dos exercícios não se poder utilizar as bibliotecas já existentes. Foi nescessario
criarmos as nossa propiás funções o que até foi algo desafiador e interessante.
No primeiro exercicio tive algumas duvidas devido ao uso do cmap =”gray”, não tinha a
certeza se se podia usar ou não. Decidi mostrar a cor através de uma imagem de 200x200 pixeis
para melhorar a interaçao com o utilizador.
No segundo exercicio na alinea a) não percebi bem o que o enunciado queria ao dizer
que devemos calcular o significado de cada cor, por isso apenas fiz o que percebi que foi calcular
a cor media e representala. Na alinea b decidi criar 2 funcoes separadas para cada uma das
tarefas. Isto ajuda caso nescescite de usar uma delas em um sub-programa posterior. Na alinea
c) estava a ter problemas por causa de a função não guardar o valor mais alto e passar por todos
os pixeis, cheguei a conclusão que era um problema a condição que verificava se a soma da cor
do pixel atual é maior do que a soma da cor do pixel guardado.
No exercicio 3 na alinea a) descobri mais para o fim que a imagem não rodava apenas,
ela também ficava refletida quanto ao eixo do x. Resolvi este problema ao alterar os valores que
iam ser copiados da imagem principal para a imagem rodada.
O exercicio 3 alinea b) foi um dos mais fáceis do trabalho pratico já que apenas se tinha
de percorrer a imagem original e copiar os pixeis de 4 em 4 para a imagem nova. Este método
diminui muito a qualidade da imagem já que muito pixeis são perdidos pelo processo.
No exercicio 4 tentei implementar todas as funcionalidades que o enunciado pedia mas
mesmo assim não tenho a certeza se faltava algo,fiquei confuso se devia ou não permitir ao
utilizador aplicar filtros na imagem.
No exercicio 5 utilizei uma biblioteca que ainda não lecionamos que é a Output(«How
to Use the Pytesseract.Output.DICT Function in Pytesseract | Snyk») do pytesseract.Utilizei-a
para ler a posição do texto para poder selecionar a matricula só nas bordas ignorando assim as
linhas interiores.
No exercicio dos pokemons consegui desenvolver rapidamente uma função para
reconhecer os circulos e contar o numero de circulos de cada cor. O que complicou mais foi a
parte de ler da camera, isto porque os circulos na camera não stao fixos num só lugar e o seu
tamanho pode variar muito rapidamente e alterar os valores do circulo, quan do isto acontece
impossibilita copiar a imagem do pokemon que esta do tamanho do circulo anterior para o
circulo atual ja que os tamanhos sao diferente. Tentei varias condições para resolver este
problema mas ainda acontece de vez em quando ,quando são feitos movimentos muito bruscos
ou caso o circulo saia para fora da imagem rapidamente.
Este trabalho levou no total cerca de 24 horas em que 12 horas foram o
desenvolvimento do relatorio.Sempre estou presente nas aulas o que permitiu uma facil
compreençao do trabalho.Em media costumo gastar 7/8 horas semanais extracurriculares com
a disciplina para o desenvolvimento de trabalhos e curiosidades que venho tendo.
5. Conclusão
Em geral achei este trabalho pratico mais complexo que o anterior, isto também se
deve ao facto de ter confruntado muito mais problemas devido a erros e outros motivos.
Python continua a ser uma linguagem interessante mas complica um bocado quando não se
pode ter acesso a bibliotecas que já facilitam algumas funcionalidade. Concluo assim que
python permite criar muitos programas interessantes mesmo sem o auxilio de bibliotecas,
mas com uma complexidade mais elevada.

Referências
Hoffstaetter, Samuel. pytesseract: Python-tesseract is a python wrapper for Google’s
Tesseract-OCR. 0.3.10. PyPI, https://github.com/madmaze/pytesseract. Acedido
20 de novembro de 2022.
«How to Use the Pytesseract.Output.DICT Function in Pytesseract | Snyk». Snyk
Advisor, https://snyk.io/advisor. Acedido 20 de novembro de 2022.
opencv-python: Wrapper package for OpenCV python bindings. 4.6.0.66, MacOS,
Microsoft :: Windows, POSIX, Unix. PyPI, https://github.com/skvark/opencv-
python. Acedido 20 de novembro de 2022.
scikit-image: Image processing in Python. 0.19.3, MacOS, Microsoft :: Windows,
POSIX, Unix. PyPI, https://scikit-image.org. Acedido 20 de novembro de 2022.
[5] Exercicios e slides disponiveis no inforestudante

Relatorio TP2

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Relatorio TP2

Enviado por

Direitos autorais:

Formatos disponíveis

Trabalho prático nº 2: Scikit-image e OpenCV

Licenciatura em Engenharia Informática

Realizado em: 20/11/2022

Raul Marian Aconstantinesei

Multimédia e Computação Gráfica 2022/2023 Pág. 1 de 33

Multimédia e Computação Gráfica 2022/2023 Pág. 2 de 33

3.6.a. Recognize pokemons in real-time images ........................................... 31

Multimédia e Computação Gráfica 2022/2023 Pág. 3 de 33

Multimédia e Computação Gráfica 2022/2023 Pág. 4 de 33

1.1. Requisitos e tutoriais

1.1.1. OpenCV (opencv-python)

1.1.2. Scikit-image (scikit-image)

1.1.2. Pytesseract (Hoffstaetter)

2.1. Understanding the basics of gray image processing

Multimédia e Computação Gráfica 2022/2023 Pág. 5 de 33

Multimédia e Computação Gráfica 2022/2023 Pág. 6 de 33

file = input("Please insert the image path: ")

2.2. Understanding the basics of color image processing

file = input("Please insert the image path: ")

file = input("Please insert the image path: ")

Apos se ter o nescessario pede-se entao chamar a funcao.

Multimédia e Computação Gráfica 2022/2023 Pág. 7 de 33

Apos se alterar os valores do pixel é mostrada a imagem para permitir a confirmaçao da

Para se executar esta funcao apenas é nescessario pedir o caminho da imagem.

file = input("Please insert the image path: ")

Multimédia e Computação Gráfica 2022/2023 Pág. 8 de 33

2.3. Understanding the basics of image transformations

Por fim é mostrada a imagem rodada.

Multimédia e Computação Gráfica 2022/2023 Pág. 9 de 33

Multimédia e Computação Gráfica 2022/2023 Pág. 10 de 33

Multimédia e Computação Gráfica 2022/2023 Pág. 11 de 33

image = Funcao escolhida pelo utilizador

2.5. OpenCV - Licence Plate

Multimédia e Computação Gráfica 2022/2023 Pág. 12 de 33

Esta função recebe como parametros apenas a imagem da matrícula.

2.6. OpenCV - Pokemons

if circle is not None:

Multimédia e Computação Gráfica 2022/2023 Pág. 13 de 33

Na alínea a) é necessário enviar apenas uma imagem inserida pelo utilizador.

file = input("Please insert the image path: ")

Na alínea c) é nescessario reconhecer os pokemons em imagens em tempo real o que apenas

Multimédia e Computação Gráfica 2022/2023 Pág. 14 de 33

2.7.1. Menu Inicial

2.7.2. Menu Exercicio 1

2.7.3. Menu Exercicio 2

2.7.4. Menu Exercicio 3

Multimédia e Computação Gráfica 2022/2023 Pág. 15 de 33

2.7.5. Menu Exercicio 4

2.7.6. Menu Exercicio 5

2.7.7. Menu Exercicio 6

2.7.8. Menu Pokemons

Multimédia e Computação Gráfica 2022/2023 Pág. 16 de 33

Output 1: Menu Inicial

3.1. Understanding the basics of gray image processing

Output 2: Exercicio 1 Menu

3.1.a. Show the algoritm

Multimédia e Computação Gráfica 2022/2023 Pág. 17 de 33

3.1.b. Test the function color2gray(color)

Output 4:Input alinea b)

De seguida será mostrado o resultado.

Output 5: Escala de cinzento da cor RGB (133,200,230)

Seguido da exibição de uma imagem com a cor respetiva.