Categorias:

Python para Ciência de Dados – Numpy

Hoje temos:

  • Processamenteo de imagem como array
  • Filtros aplicados a imagens
# In[1]:


#Importar os pacotes que utizaremos
import numpy as np
from scipy import misc
import matplotlib.pyplot as plt
get_ipython().run_line_magic('matplotlib', 'inline')


# In[29]:


#Fazer a leitura da nossa imagem
from skimage import data

photo_data = misc.imread('./wifire/ima.jpg')

type(photo_data)


# In[3]:


plt.figure(figsize=(15,15))
plt.imshow(photo_data)


# In[4]:


#Vamos ver o shape dessa foto/desse array
photo_data.shape


# In[14]:


# print(photo_data)


# In[15]:


#Nós podemos também verificar o tamanho da imagem:
photo_data.size


# In[16]:


#É possível também visualizar qual o máximo e mínimo da imagem. E isso é importante porque
# os valores na escala RGB só podem ir de 0 a 255
photo_data.min(), photo_data.max()


# In[17]:


# Você pode ver  a média também
photo_data.mean()


# In[18]:


#Suponhamos que você quer ver qual o valor de um pixel. Você fará da seguinte forma:
"""
Você deve ter em mente que agora temos uma matriz com 3 dimensões, ou seja:
1. linha
2. coluna
3. valores das cores

Portanto, quando acessarmos um valor, ele retornará 3 valores, que são os valores do Red, Green e Blue - RGB
"""
photo_data[160][120]


# In[20]:


"""
Você pode querer acessar uma cor específica. Para isso, é só indicar qual o índice da cor:
0 - red
1 - green
2 - blue

Vamos pegar o valor do azul, na linha com índice 150 com a coluna índice 2543
"""
photo_data[150][2543][2]


# In[24]:


"""
Você pode também mudar os valores - lembre-se que agora a imagem é um array.
Vamos definir que todas as camadas da linha de indice 1000 e da coluna de indice 2000 ficarão preta.
"""
photo_data[1000,2000] = 0
plt.figure(figsize=(10,10))
plt.imshow(photo_data)


# In[30]:


"""
A gente mudou apenas uma pequena coisa. Nós podemos fazer isso para um range de valores também:
vamos mudar da linha de índice 500 até a coluna de índice 2000, alterando a cor para branco.
"""
photo_data[:500,:2000] = 255
plt.figure(figsize=(10,10))
plt.imshow(photo_data)


# In[35]:


"""
A gente pode mudar também só uma camada:
"""
photo_data = misc.imread('./wifire/ima.jpg')

photo_data[100:2300, : , 0] = 0
plt.figure(figsize=(10,10))
plt.imshow(photo_data)


# In[53]:


"""
A gente pode também criar filtros.
É importante lembrar que ambos devem ter as mesmas características, pois o nosso filtro não alterará nada,
só retornara um array com valores booleanos para podermos utilizar
"""
import imageio 

photo_data = imageio.imread('./wifire/ima.jpg')
print("Shape da nossa foto: ", photo_data.shape)
filtro_valores_baixos = photo_data < 50
print("Shape dos nossos valores baixos: ", filtro_valores_baixos.shape)



# In[55]:


#Filtrando resultados pequenos
plt.figure(figsize=(15,15))
plt.imshow(photo_data)
# Onde os valores forem menor que 50, como definido acima, deixe como 0
photo_data[filtro_valores_baixos] = 255
plt.figure(figsize=(15,15))
plt.imshow(photo_data)


# In[62]:


#Mais algumas operações
#criar um range de linhas:
photo_data = imageio.imread('./wifire/ima.jpg')

range_linhas = np.arange(len(photo_data))
range_colunas = range_linhas
print(type(range_linhas),range_linhas)


# In[63]:


# aqui ele pega os pares de cima, 00,11,22,33,44,55,66,77,88 e coloca como 255 para os valores do array
photo_data[range_linhas,range_colunas] = 255


# In[64]:


plt.figure(figsize=(15,15))
plt.imshow(photo_data)


# In[69]:


#Agora vamos fazer algo ainda mais legal: vamos tentar pegar um círculo dessa imagem.
"""
A seguir vamos passar o shape da nossa foto para o total de linhas, total de colunas e total de camadas.
"""
total_linhas, total_colunas, total_camadas = photo_data.shape
#Crie um grid com todas as linhas e com todas as colunas
X, Y = np.ogrid[:total_linhas, :total_colunas]
print(X.shape, Y.shape)
#


# In[70]:


#Agora vamos calcular a linha central e a coluna central
linha_central, coluna_central = total_linhas / 2, total_colunas / 2


# In[71]:


#Vamos ver a distância do centro:
dist_do_centro = (X - linha_central)**2 + (Y - linha_central)**2

#Calcular o radius
radius = (total_linhas / 2)**2

#Calcular a mascara circular que será onde a distancia do centro for mais que o radius
mascara_circular = (dist_do_centro > radius)


# In[74]:


#Filtrando com a mascara
photo_data = imageio.imread('./wifire/ima.jpg')
plt.figure(figsize=(15,15))
plt.imshow(photo_data)
photo_data[mascara_circular] = 0
plt.figure(figsize=(15,15))
plt.imshow(photo_data)


# ## Mais máscaras

# In[80]:


X, Y = np.ogrid[:total_linhas, :total_linhas]
metade_cima = X < linha_central

mascara_metade = np.logical_and(metade_cima, mascara_circular)


# In[84]:


photo_data = imageio.imread('./wifire/ima.jpg')
photo_data[mascara_metade] = 0
# import random
# photo_data[mascara_metade] = random.randint(200,255)
plt.figure(figsize=(15,15))
plt.imshow(photo_data)


# In[85]:


"""
Agora vamos criar máscaras para as cores. A primeira cor será a vermelha.
"""

foto = imageio.imread('./wifire/ima.jpg')
mascara_vermelha = foto[:,:,0] < 150

foto[mascara_vermelha] = 0
plt.figure(figsize=(15,15))
plt.imshow(foto)


# In[86]:


foto = imageio.imread('./wifire/ima.jpg')
mascara_verde = foto[:,:,1] < 150

plt.figure(figsize=(15,15))
plt.imshow(foto)


# In[87]:


foto = imageio.imread('./wifire/ima.jpg')
mascara_verde = foto[:,:,2] < 150

plt.figure(figsize=(15,15))
plt.imshow(foto)

Deixe um comentário

O seu endereço de e-mail não será publicado.

Esse site utiliza o Akismet para reduzir spam. Aprenda como seus dados de comentários são processados.