<jupyter_start><jupyter_text>![header](../header.png)  Guia de Processamento Digital de Imagens em linguagem de programação Python Estudo de caso em Reconhecimento Automático de Placas Veiculares DescriçãoEsse guia é composto de diversos notebooks que têm por principal objetivo apresentar o desenvolvimento de algoritmos em linguagem python com uso da biblioteca de visão computacional OpenCV. Para isso, toma como exemplo um estudo de caso em reconhecimento automático de placas veiculares. As imagens utilizadas são do [SSIG-ALPR Database](http://www.smartsenselab.dcc.ufmg.br/ssig-alpr-database). Notebook número 1Esse notebook tem por objetivo introduzir um pouco da linguagem python, em especial a biblioteca Numpy. Esse biblioteca facilitará os cálculos vetoriais e matriciais, além de incluir uma diversidade de funções estatísticas.Nesse caso, o primeiro passo a ser dado é a importação das bibliotecas.<jupyter_code># Use # para adicionar comentarios de uma linha
import numpy as np<jupyter_output><empty_output><jupyter_text>Criando Vetores e Matrizes<jupyter_code>#Criando vetor linha
vector_row = np.array([1,2,3])

#Criando vetor coluna
vector_column = np.array([[1],[2],[3]])

#Exibindo os vetores
print ('vector_row = ',vector_row)
print ('vector_column = \n',vector_column)

#Criando uma matriz
matrix = np.array([[1,2,3],[4,5,6]])
print('matrix = \n',matrix)

#Criando matriz de uns e zeros especificando tipo de variavel
matrix_1s = np.ones([2,3],'float')
matrix_0s = np.zeros([1,5],'uint8')
print('matrix_1s = \n',matrix_1s)
print('matrix_0s = ',matrix_0s)

#Criando vetor a partir de valor inicial, final e passo
vector_arange = np.arange(0,1,0.1,'float')
print('vector_arange = ',vector_arange)

#Criando vetor a partir de valor inicial, final e quantidade de elementos
vector_linspace = np.linspace(0,1,11,'float')
print('vector_linspace = ',vector_linspace)<jupyter_output>vector_row =  [1 2 3]
vector_column = 
 [[1]
 [2]
 [3]]
matrix = 
 [[1 2 3]
 [4 5 6]]
matrix_1s = 
 [[1. 1. 1.]
 [1. 1. 1.]]
matrix_0s =  [[0 0 0 0 0]]
vector_arange =  [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
vector_linspace =  [0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]<jupyter_text>Selecionando elementos<jupyter_code>#Criando vetor linha
vector_row = np.array([ 1,2,3,4,5,6 ])
print(vector_row,'\n')

#Criando uma matriz
matrix = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(matrix,'\n')

#Selecionando terceiro elemento do vetor
print(vector_row[2],'\n')

#Selecionando elemento da segunda linha e segunda coluna da matriz
print(matrix[1,1],'\n')

#Selecionando todos os elementos do vetor
print(vector_row[:],'\n')

#Selecionando tudo até e incluindo o terceiro elemento do vetor
print(vector_row[:3],'\n')

#Selecionando tudo após o terceiro elemento do vetor
print(vector_row[3:],'\n')

#Selecionando o último elemento do vetor
print(vector_row[-1],'\n')

#Selecionando as duas primeiras linhas e todas as colunas da matriz
print(matrix[:2,:],'\n')

#Selecionando todas as linhas e a segunda coluna da matriz
print(matrix[:,1:2])<jupyter_output>[1 2 3 4 5 6] 

[[1 2 3]
 [4 5 6]
 [7 8 9]] 

3 

5 

[1 2 3 4 5 6] 

[1 2 3] 

[4 5 6] 

6 

[[1 2 3]
 [4 5 6]] 

[[2]
 [5]
 [8]]<jupyter_text>Descrevendo uma matriz<jupyter_code>#Criando uma matriz
matrix = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]])
print(matrix,'\n')

#Visualizando o número de linhas e de colunas da matríz
print(matrix.shape)
print('Linhas: ',matrix.shape[0])
print('Colunas: ',matrix.shape[1],'\n')

#Visualizando numero de elementos (linhas*colunas)
print(matrix.size,'\n')

#isualizando o numero de dimensoes(nesse caso 2)
print(matrix.ndim)<jupyter_output>[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]] 

(4, 3)
Linhas:  4
Colunas:  3 

12 

2<jupyter_text>Extraindo informações<jupyter_code>print(matrix,'\n')

#Return the max element
print('Maximo = ',np.max(matrix))

#Return the min element
print('Minimo = ',np.min(matrix))

#To find the max element in each column
print('Maximo por coluna = ',np.max(matrix,axis=0))

#To find the max element in each row
print('Maximo por linha = ',np.max(matrix,axis=1))
print(matrix,'\n')

#Média
print('Media = ',np.mean(matrix))

#Desvio padrão
print('Desvio padrão = ',np.std(matrix))

#Variancia
print('Variancia = ',np.var(matrix))<jupyter_output>[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]] 

Media =  6.5
Desvio padrão =  3.452052529534663
Variancia =  11.916666666666666<jupyter_text>Reshaping<jupyter_code>#Criando uma matriz
matrix = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(matrix,'\n')

#Reshape
print(matrix.reshape(9,1),'\n')

#Aqui -1 significa quantas colunas forem necessárias e 1 linha
print(matrix.reshape(1,-1),'\n')

#Se for fornecido apenas 1 valor será retornado um vetor 1-d com esse comprimento
print(matrix.reshape(9),'\n')

#Pode-se usar o método Flatten para converter a matrix em um vetor 1-d
print(matrix.flatten(),'\n')<jupyter_output>[[1 2 3]
 [4 5 6]
 [7 8 9]] 

[[1]
 [2]
 [3]
 [4]
 [5]
 [6]
 [7]
 [8]
 [9]] 

[[1 2 3 4 5 6 7 8 9]] 

[1 2 3 4 5 6 7 8 9] 

[1 2 3 4 5 6 7 8 9]<jupyter_text>Operações Matriciais<jupyter_code>#Criando uma matriz
matrix = np.array([[-1,1,1],[2,-2,2],[3,3,-3]])
print(matrix,'\n')

#Transposta
print('Transposta = \n', matrix.T)

#Inversa
print('Inversa = \n', np.linalg.inv(matrix))

#Determinante
print('Determinante = ', np.linalg.det(matrix))

#Diagonal principal
print('Diagonal principal = ', matrix.diagonal())

#Diagonais secundarias
print('Diagonal secundaria uma abaixo = ', matrix.diagonal(offset=1))
print('Diagonal secundaria uma acima = ', matrix.diagonal(offset=-1))
#Criando Matrix-1
matrix_1 = np.array([[1,2,3],[4,5,6],[7,8,9]])
#Criando Matrix-2
matrix_2 = np.array([[7,8,9],[4,5,6],[1,2,3]])

#Soma
print(np.add(matrix_1,matrix_2))

#Subtração
print(np.subtract(matrix_1,matrix_2))

#Multiplicação ponto a ponto
print(matrix_1 * matrix_2)

#Multiplicação de matrizes
print(matrix_1 @ matrix_2)

#Criando Matrix-3
matrix_3 = 2*np.ones([3,3],'uint8')

#Potenciação ponto a ponto
print(matrix_1 ** matrix_3)<jupyter_output>[[ 8 10 12]
 [ 8 10 12]
 [ 8 10 12]]
[[-6 -6 -6]
 [ 0  0  0]
 [ 6  6  6]]
[[ 7 16 27]
 [16 25 36]
 [ 7 16 27]]
[[ 18  24  30]
 [ 54  69  84]
 [ 90 114 138]]
[[ 1  4  9]
 [16 25 36]
 [49 64 81]]<jupyter_text>Gerando números aleatórios<jupyter_code>#Criando semente (seed)
np.random.seed(1)

#Gerando 3 inteiros aleatórios entre 1 e 10
print(np.random.randint(0,11,3))

#Gerando 3 numeros a partir de uma distribuicao normal com media 1.0 e desvio padrao 2.0
print(np.random.normal(1.0,2.0,3))<jupyter_output>[5 8 9]
[-0.60434568  0.10224438 -1.21187015]
{'fraction_non_alphanumeric': 0.1514277035236938, 'fraction_numerical': 0.07411907654921021, 'mean_word_length': 4.927092709270927, 'pattern_counts': {'":': 0, '<': 26, '<?xml version=': 0, '>': 26, 'https://': 0, 'lorem ipsum': 0, 'www.': 1, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 1, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '8', 'dir': 'jupyter-structured-clean-dedup', 'id': '618792', 'license': 'MIT', 'n_tokens_mistral': 3043, 'n_tokens_neox': 2776, 'n_words': 743, 'path': 'Guia/Notebook01-IntroducaoPython.ipynb', 'repo_name': 'LuizPitaAlmeida/GUIA_PDI_PYTHON_ALPR', 'size': '6584'}