Centro Universitário Facens

Disciplina: Processamento de Imagens

Prof. Renato Moraes Silva

Exercício - Introdução ao Python

Neste exercício, são apresentados alguns recursos básicos do Python que geralmente são
necessários nos projetos de Processamento de Imagens.

Numpy - vetores e matrizes

A biblioteca numpy do python permite a criação, manipulações e operações matemáticas de
vetores e matrizes.
Primeiro, você deve importar a biblioteca, antes de usar suas funções.
# -*- coding: utf-8 -*-

import numpy as np # importa a biblioteca usada para trabalhar com

vetores e matrizes.

Criando vetores e matrizes

Criando um vetor com os seguintes valores [ 1 ,2 , 3 , 4 , 5 ) .
# criando um vetor
vet = np.array( [1,2,3,4,5] )

# você pode imprimir usando a função print ou a função display

print(vet)
display(vet)

[1 2 3 4 5]

array([1, 2, 3, 4, 5])

Podemos criar um vetor de elementos sequenciais usando a função arange do numpy. Por
exemplo, vamos criar um vetor com valores de 0 até 7.
vet_seq1 = np.arange(8)

display(vet_seq1)

array([0, 1, 2, 3, 4, 5, 6, 7])
Agora, vamos criar um vetor de elementos sequenciais de 5 até 10.
vet_seq1 = np.arange(5,11)

display(vet_seq1)

array([ 5, 6, 7, 8, 9, 10])

Nós podemos também criar um vetor sequencial variando de 2 em 2 ou com outros

intervalos.
vet_seq1 = np.arange(5,20,2)
print('Sequência de 5 até 20, variando de 2 em 2:', vet_seq1)

vet_seq1 = np.arange(5,20,5)
print('Sequência de 5 até 20, variando de 5 em 5:', vet_seq1)

vet_seq1 = np.arange(5,20,4)
print('Sequência de 5 até 20, variando de 4 em 4:', vet_seq1)

Sequência de 5 até 20, variando de 2 em 2: [ 5 7 9 11 13 15 17 19]

Sequência de 5 até 20, variando de 5 em 5: [ 5 10 15]
Sequência de 5 até 20, variando de 4 em 4: [ 5 9 13 17]

Vetores sequenciais podem ser usados em laços de repetição. Por exemplo, vamos imprimir
todos os valores entre 2 e 10 usando um laço de repetição for.
for i in np.arange(2,11):
print('%d' %i)

2
3
4
5
6
7
8
9
10

Nós também podemos criar um vetor com n -zeros ou n -uns.

# cria um vetor com 10-zeros
vet_zeros = np.zeros(10)

# cria um vetor com 10-uns

vet_ones = np.ones(10)

print('Vetor de zeros: ', vet_zeros)

print('\nVetor de uns: ', vet_ones)
Vetor de zeros: [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]

Vetor de uns: [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]

Criando uma matriz com os valores: $ \begin{bmatrix} 1 & 2 & 3 & 4 & 5 \ 6 & 7 & 8 & 9 &
10 \end{bmatrix}$
# cria uma matriz
A = np.array( [[1,2,3,4,5],[6,7,8,9,10]] )

display(A)

array([[ 1, 2, 3, 4, 5],
[ 6, 7, 8, 9, 10]])

Uma matriz é também uma imagem. Portanto, pode plotar a imagem gerada pela matriz
acima. Para isso, você pode usar a função imshow da biblioteca biblioteca
matplotlib.pyplot.

Quando queremos que a imagem seja plotada em tons de cinza, é necessário passar o
argumento 'gray' para o método imshow, além de informar o maior (vmax) e o menor
(vmin) valor da escala de cinza. Por exemplo, considerando que a imagem tenha 16 tons de
cinza, vmax deve ser setado com 15, enquanto vmin com 0. Se nenhum valor for passado, o
método considera o maior e o menor tom de cinza automaticamente, com base nos pixels
da imagem de entrada.
Obs.: converta a imagem para o tipo uint8 usando a função astype.
import matplotlib.pyplot as plt

# converte para uint8

A = A.astype(np.uint8)

# plota a imagem A. Use o parâmetro 'gray'

# para que a imagem seja mostrada em tons de cinza
plt.imshow(A, 'gray', vmin=0, vmax=15)
plt.show() # mostra a imagem
Caso você queira gerar uma imagem colorida, você deve criar uma matriz onde o valor de
cada linha e coluna é um vetor de três dimensões cujos valores podem variar entre 0 e 255.
Odefina a imagem com o tipo uint8.
# cria uma matriz
B = np.array( [
[[0,0,255 ],[0,255,255],[255,0,0]],
[[255,0,255],[100,200,0],[0,255,0]]
] )

# plota a imagem A
plt.imshow(B)
plt.show() # mostra a imagem

Nós também podemos criar uma matriz de valores zero e uma matriz de valores um:
# cria um array de valores zeros com dimensão 2x10
array_zeros = np.zeros( [2,10] )

# cria um array de valores um com dimensão 2x10

array_ones = np.ones( [2,10] )

print('Vetor de zeros: ')

display(array_zeros)

print('\nVetor de valores um: ')

display(array_ones)

Selecionando elementos de vetores e matrizes

Suponha que temos um vetor [ a , b , c , d , e , f , g , h , i ). Nós podemos selecionar vários
subconjuntos de elementos desse vetor, como:
• três primeiros elementos
• todos os valores após o quinto elemento
 • os três ultimos valores
• os valores entre o quinta elemento até o penúltimo elemento
Observação: no python, o índice começa a contar em 0.
# criando um vetor
vetA = np.array(['a','b','c','d','e','f','g','h','i'])

print('Três primeiros elementos de vetA: ')

print( vetA[0:3] )

print('\ntodos os valores após o Quinto elementos de vetA: ')

print( vetA[5:] )

print('\nOs três ultimos valores de vetA: ')

print( vetA[-3:] )

print('\nOs valores de vetA entre o 5 elemento até o penúltimo

elemento: ')
print( vetA[4:-2], 'ou', vetA[4:7] )

[ )
1a 1b 1c 1d 1e 1f 1g 1h 1i
2a 2b 2c 2d 2e 2f 2g 2h 2i
Suponha que temos um array: .
3a 3b 3c 3d 3e 3f 3g 3h 3i
4a 4b 4c 4d 4e 4f 4g 4h 4i

Nós podemos selecionar vários subconjuntos de elementos dessa matriz, como:

• todos os elementos da coluna 3
• todos os elementos da linha 2
• todos os elementos das duas primeiras colunas
• todos os elementos das duas primeiras linhas
• apenas os elementos das 2 primeiras linhas e das 2 primeiras colunas
• apenas os elementos das 2 últimas linhas e das 4 últimas colunas
• apenas os elementos das linhas 2 até 4 e das colunas 4 até 6
# criando uma matriz
arrayA = np.array( [['1a','1b','1c','1d','1e','1f','1g','1h','1i'],
['2a','2b','2c','2d','2e','2f','2g','2h','2i'],
['3a','3b','3c','3d','3e','3f','3g','3h','3i'],
['4a','4b','4c','4d','4e','4f','4g', '4h','4i']])

print('Matriz inteira: ')

print( arrayA )

print('\nTodos os elementos da coluna 3: ')

print( arrayA[:,2] )

print('\nTodos os elementos da linha 2: ')

print( arrayA[1:,:] )

print('\nTodos os elementos das 2 primeiras colunas: ')

print( arrayA[:,0:2] )

print('\nTodos os elementos das 2 primeiras linhas: ')

print( arrayA[0:2,:] )

print('\nApenas os elementos das 2 primeiras linhas e das 2 primeiras

colunas: ')
print( arrayA[0:2,0:2] )

print('\nApenas os elementos das 2 últimas linhas e das 4 últimas

colunas: ')
print( arrayA[-2:,-4:] )

print('\nApenas os elementos das linhas 2 até 4 e das colunas 4 até 6:

')
print( arrayA[1:3,3:6] )

Nós podemos combinar as operações mostradas acima para gerar imagens. Por exemplo,
no exemplo abaixo, iremos criar uma imagem toda azul.
# cria uma matriz de 2x2x3 com
# todos os valores 0
img1 = np.zeros([2,2,3], dtype=int)

# agora iremos colocar o valor 255 no terceiro

# canal de cor (índice 2) de cada linha e coluna
img1[ :,:,2 ] = 255

# plota a imagem.
plt.imshow(img1)
plt.show() # mostra a imagem

Agora, iremos misturar a cor azul da imagem com uma nova cor: a verde. Para isso, iremos
adicionar a cor verde no segundo canal de cor de cada pixel da primeira coluna da imagem.
# iremos colocar o valor 255 no segundo
# canal de cor (índice 1) de primeira coluna da imagem
img1[ :,0,1 ] = 255

# plota a imagem
plt.imshow(img1)
plt.show() # mostra a imagem

Iremos pintar a última linha com a cor vermelha.

# iremos colocar a cor vermelha na última linha
img1[ -1,:,: ] = [255,0,0]
# plota a imagem
plt.imshow(img1)
plt.show() # mostra a imagem

Operações básicas com vetores e matrizes

Soma e subtração entre vetores.
A = np.array( [1,2,3] )
B = np.array( [4,5,6] )
print('A:', A);
print('B:', B);

print('\nA+B: ', A+B )

print('A-B: ', A-B )

Soma e subtração entre matrizes.

X1 = np.array( [[1,2,3],
[4,5,6]] )

X2 = np.array( [[4,5,6],
[7,8,9]])

print('X1: \n', X1);

print('\nX2: \n', X2);

print('\nX1+X2:')
display(X1+X2)

print('\nX1-X2:')
display(X1-X2)

Produto entre duas matrizes.

Obs.: para isso ser possível, a quantidade de colunas da primeira, deve ser igual a
quantidade de linhas da segunda
A = np.array( ([[1,2],[3,4],[5,6]]) )
B = np.array( ([[1,2,3,4],[5,6,7,8]]) )

print('A: ')
display(A)

print('B: ')
display(B)

print('A*B: ')
display(np.dot(A,B))
Média dos valores de uma matriz.
print('B: ')
display(B)

# média das linhas de B

media1 = np.mean(B, axis = 1)
print('\nMédia das linhas de B: ')
display(media1)

# média das colunas de B

media2 = np.mean(B, axis = 0)
print('\nMédia das colunas de B: ')
display(media2)

# média de todos os valores de B

media3 = np.mean(B)
print('\nMédia de todos os valores de B: ')
display(media3)

Desvio padrão dos valores de uma matriz.

print('B: ')
display(B)

# desvio padrão das linhas de B

std1 = np.std(B, axis = 1, ddof=1)
print('\nDesvio padrão das linhas de B: ')
display(std1)

# desvio padrão das colunas de B

std2 = np.std(B, axis = 0, ddof=1)
print('\nDesvio padrão das colunas de B: ')
display(std2)

# desvio padrão de todos os valores de B

std3 = np.std(B, ddof=1)
print('\nDesvio padrão de todos os valores de B: ')
display(std3)

Mediana dos valores de uma matriz

print('A: ')
display(A)

# média das linhas de B

mediana1 = np.median(A, axis = 1)
print('\nMediana das linhas de A: ')
display(mediana1)
# média das colunas de B
mediana2 = np.median(A, axis = 0)
print('\nMediana das colunas de A: ')
display(mediana2)

# média de todos os valores de B

mediana3 = np.median(A)
print('\nMediana de todos os valores de A: ')
display(mediana3)

Outras funções para vetores e matrizes.

• np.min() → valor mínimo
• np.max() → valor máximo
• np.sort(A) → retorna o vetor A ordenado
• np.argsort(A) → retorna os índices do vetor A ordenado
• np.var() → variância
• np.shape() → dimensões da matriz
• np.transpose() → transposta da matriz
• np.concatenate(arrays, axis=numero_do_eixo) → concatena vetores ou
matrizes
• vstack(A,B) → empilha verticalmente
• hstack(A,B) → empilha horizontalmente
• np.where(A>n) → elementos em A maiores que n

Exercícios
Ex. 1. Crie duas matrizes com os nomes E x A e E x B preenchidas com os seguintes valores:
$ExA = \begin{bmatrix} 12 & 9 & 4 & 1 \ 11 & 5 & 8 & 1 \ 1 & 2 & 3 & 1 \ \end{bmatrix} $,
$ ExB = \begin{bmatrix} 1 & 5 \ 1 & 7 \ 1 & 9 \ 1 & 1 \ \end{bmatrix} $. Após isso, imprima
as duas matrizes.
################# ESCREVA SEU CÓDIGO AQUI
###############################

######################################################################
####

Ex. 2. Crie uma matriz E x C usando a seguinte operação: E x C=E x A ⋅ E x B . Depois,

imprima E x C .
################# ESCREVA SEU CÓDIGO AQUI
###############################
######################################################################
####

Ex. 3. Crie uma função que retorne a média e o desvio padrão das linhas de uma matriz e a
média e desvio padrão das colunas de uma matriz. Depois teste sua função com a matriz
E x C.
################# ESCREVA SEU CÓDIGO AQUI
###############################

######################################################################
####

Ex. 4. Crie uma matriz E x D com os valores das duas últimas colunas de E x A . Depois,
calcule a média dos valores de E x D .
################# ESCREVA SEU CÓDIGO AQUI
###############################

######################################################################
####

Ex. 5. Crie uma matriz E x E com os valores das linhas 1 e 2 e das colunas 1 e 2 de E x A .
################# ESCREVA SEU CÓDIGO AQUI
###############################
######################################################################
####

Ex. 6. Crie e imprima uma matriz E x F com 5 linhas e 2 colunas e todos os valores iguais a
0.
################# ESCREVA SEU CÓDIGO AQUI
###############################

######################################################################
####

Ex. 7. Crie e imprima uma matriz E x G com 4 linhas e 3 colunas e todos os valores iguais a
1.
################# ESCREVA SEU CÓDIGO AQUI
###############################

######################################################################
####

Ex. 8. Crie uma função que retorne o fatorial de um número. Teste a função que você criou,
calculando o fatorial de 8.

Fórmula do fatorial: n !=( 1∗2∗3∗.. .∗( n −2 )∗( n− 1 )∗n )

Obs: é obrigatório usar um laço for.

Exemplos:
• 1 !=1
• 2 !=1∗2
• 3 !=1∗2∗3
 • 4 !=1∗2∗3∗4
• 5 !=1∗2∗3∗4∗5
################# ESCREVA SEU CÓDIGO AQUI
###############################

######################################################################
####

Ex. 9. Crie um retângulo na cor verde. Depois, desenhe a letra E maiúscula nesse retângulo
com a cor vermelha.
################# ESCREVA SEU CÓDIGO AQUI
###############################

imagem = np.zeros( [20,20,3],

dtype = np.uint8 )
# amarelo
#imagem[ :, :, : ] = [255, 255,0]

imagem[:,:,1] = 255
imagem[2:-2, 2:4, :] = [255,0,0] # retangulo maior do E
imagem[2:4, 4:14, :] = [255,0,0] # primeira perna do E
imagem[9:11,4:10, :] = [255,0,0]
imagem[-4:-2,4:14,:] = [255,0,0]

# plota a imagem
plt.imshow(imagem)
plt.show()
######################################################################
####