giovani_ex1

Enunciado:

  1. Se registrar no Adessowiki e criar a sua página de diário do curso - OK
  2. Estudar o Python (primer ou tutorial) http://docs.python.org/tutorial - OK
  3. Estudar o NumPy (tutorial, para entender arrays e pequenos truques de processamento de imagem). http://www.scipy.org/Tentative_NumPy_Tutorial - OK
  4. Fazer um exercício que mostre os principais conceitos aprendidos. Procure fazer exercícios com matriz numérica de tamanho reduzido. - OK
  5. Estudar formas de gerar uma imagem xadrez e implementar algumas de sua preferência. - OK

  1. Exemplos de criação de matriz e manipulação delas, bem como algumas técnicas do Python.
 1 # criando um array (matriz) a partir de uma lista de listas
 2 matriz = array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])
 3 print "\n matriz - Matriz: \n"
 4 print matriz
 5 
 6 # criando um array a partir das funções zeros e ones que recebe uma tupla com as dimensões
 7 zero = zeros((4,3))
 8 print "\n zero - Matriz de zeros: \n"
 9 print zero
10 print "\n um - Matriz de uns: \n"
11 um = ones((2,5))
12 print um
13 # as imagens na toolbox pymorph também são objetos array
14 img = mmreadgray('cameraman.tif')
15 print "\n img - Dimensão da matriz cameraman.tif: \n"
16 print img.shape
matriz - Matriz: 

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

 zero - Matriz de zeros: 

[[ 0.  0.  0.]
 [ 0.  0.  0.]
 [ 0.  0.  0.]
 [ 0.  0.  0.]]

 um - Matriz de uns: 

[[ 1.  1.  1.  1.  1.]
 [ 1.  1.  1.  1.  1.]]

 img - Dimensão da matriz cameraman.tif: 

(256, 256)

Funções do Pacote

Algumas das funções apresentadas abaixo podem ser acessadas tanto do pacote, como membros do objeto:

 1 a = array([[1, 2, 3],[4, 5, 6],[7, 8, 9]]) # cria uma matriz de dim. 3x3
 2 print "\n a - Matriz: \n"
 3 print a
 4 
 5 a.resize((3,4)) # altera o objeto a, novas posições são preenchidas com zero
 6 print "\n a - Matriz resize (3,4): \n"
 7 print a
 8 
 9 b = array([[1, 2, 3],[4, 5, 6],[7, 8, 9]])
10 print "\n b - Matriz: \n"
11 print b
12 
13 c = resize(b, (3,4)) # retorna um objeto com tamanho (3,4) e com as posições preenchidas a partir de b
14 print "\n c - Matriz resize (3,4): \n"
15 print c
a - Matriz: 

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

 a - Matriz resize (3,4): 

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

 b - Matriz: 

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

 c - Matriz resize (3,4): 

[[1 2 3 4]
 [5 6 7 8]
 [9 1 2 3]]
  • reshape: mesmo comportamento do reshape do MATLAB, sendo que o número de valores na matriz deve ser mantido

  • resize: redimensiona a matriz

  • ravel: transforma o array N-D em um array 1-D

  • transpose: gera a matriz transposta

  • concatenate: concatena N matrizes.
    • Concatenando na vertical: concatenate((a,a))
    • Concatenando na horizontal: concatenate((a,a), axis=1)
  • dot: realiza multiplicação matricial. O operador de multiplicação * realiza a multiplicação ponto a ponto

  • max: retorna o maior valor da matriz

  • argmax: retorna o índice em 1-D do valor max

  • logical_and, logical_or, logical_xor, logical_not: realiza as operações and, or, xor e not ponto a ponto

  • indices: comando similar ao meshgrid do MATLAB, retorna duas matrizes com os indices a partir de zero para linhas e colunas

Slicing

Slicing é o termo utilizado para a extração e inserção de sub-matrizes. Em Python, o slicing é muito parecido com MATLAB, e também pode ser operado sobre listas. A sintaxe utilizada difere na ordem dos parâmetros. Em Python, o slicing é feito com mylist[primeiro_elemento:ultimo_elemento:passo]. Deve-se lembrar que o intervalo utilizado é do tipo [primeiro,ultimo), ou seja, o ultimo indice dado não é incluido. O primeiro índice, se for zero é opcional, e o passo se for 1 também é opcional.

Exemplos de slicing:

1 ex = ones((10,10))
2 ex[3:6,3:6] = zeros((3,3)) # atribui uma matriz 3x3 a um bloco 3x3 do quarto ao sexto elemento na linha e coluna
3 ex[4:9:2,4:9:3]= 2 # atribui a constante 2 do quinto elemento até o nono, andando de dois em dois nas linhas e 3 em 3 nas colunas
4 print "\n ex - Matriz exemplo: \n"
5 print ex
ex - Matriz exemplo: 

[[ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]
 [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]
 [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]
 [ 1.  1.  1.  0.  0.  0.  1.  1.  1.  1.]
 [ 1.  1.  1.  0.  2.  0.  1.  2.  1.  1.]
 [ 1.  1.  1.  0.  0.  0.  1.  1.  1.  1.]
 [ 1.  1.  1.  1.  2.  1.  1.  2.  1.  1.]
 [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]
 [ 1.  1.  1.  1.  2.  1.  1.  2.  1.  1.]
 [ 1.  1.  1.  1.  1.  1.  1.  1.  1.  1.]]

Exemplos com imagens:

1 img = mmreadgray('cameraman.tif') # le a imagem
2 img1 = copy(img) # copia a imagem
3 img1[150:200,10:80] = 255 # cria um retangulo branco na imagem, por slicing
4 barra = zeros((img.shape[0], 10)) # cria uma barra para separar as duas imagens
5 img3 = uint16(concatenate((img,barra,img1), axis=1))
6 mmshow(img3,title='img3 - Exemplo de leitura, slicing e concatenacao')

img3 - Exemplo de leitura, slicing e concatenacao


5. Como vimos anteriormente a utilização do Slicing, apresentaremos a confecção do tabuleiro de xadrez com essa técnica.

Tabuleiro de Xadrez:

 1 import time
 2 
 3 #------------------------------------------------------------
 4 def chess_slicing(s,t):
 5     a = zeros(s)
 6     i = 0
 7     flag = 0
 8     while i < s[0]: # Percorre a matriz pelas linhas pulando pelo tamanho quadrado
 9         if flag == 0:
10             j=0
11             while j < s[1]:
12                 a[i:i+t[0],j:j+t[1]] = ones(t) # Adiciona por slicing a submatriz de uns.
13                 j+= 2 * t[1]
14                 flag = 1
15         else:
16             j = t[1]
17             while j < s[1]:
18                 a[i:i+t[0],j:j+t[1]] = ones(t)
19                 j+= 2 * t[1]
20                 flag = 0
21         i += t[0]
22     return uint16(a)
23 
24 #-------------------------------------------------------------
25 def chess_resize(s,t):
26 
27     # cria duas linhas e faz o resize
28     r = uint16(arange(s[1])/t[1]) % 2 # Gera a linha de pixel com a largura do quadrado
29     r = resize(r,(t[0],s[1]))         # Gera a a altura do ladrilho a partir da linha feita no passo anterior
30     r = concatenate((r,1-r), axis=0)  # concatena a linha modelo para resize...
31     return resize(r, s)
32 
33 #-------------------------------------------------------------
34 
35 # Slicing
36 t1 = time.time()
37 ex1 = chess_slicing((100,100),(10,25))
38 t2 = time.time()
39 mmshow(ex1, title="ex1 - Xadrez 100x100 - Tempo: " + str(t2-t1) + "s  ")
40 
41 t1 = time.time()
42 ex2 = chess_slicing((200,200),(10,25))
43 t2 = time.time()
44 mmshow(ex2, title="ex2 - Xadrez 200x200 - Tempo: " + str(t2-t1) + "s  ")
45 
46 # Resize
47 t1 = time.time()
48 ex3 = chess_resize((100,100),(10,25))
49 t2 = time.time()
50 mmshow(ex3, title="ex3 - Xadrez 100x100 - Tempo: " + str(t2-t1) + "s  ")
51 
52 t1 = time.time()
53 ex4 = chess_resize((200,200),(10,25))
54 t2 = time.time()
55 mmshow(ex4, title="ex4 - Xadrez 200x200 - Tempo: " + str(t2-t1) + "s  ")

ex1 - Xadrez 100x100 - Tempo: 0.000242948532104s

ex2 - Xadrez 200x200 - Tempo: 0.00103807449341s

ex3 - Xadrez 100x100 - Tempo: 0.000147104263306s

ex4 - Xadrez 200x200 - Tempo: 0.000117778778076s