# Importa das bibliotecas necessárias para manipular os dataframes (dados)
import numpy as np
import pandas as pd
import seaborn as sea
from pandas import Grouper
import matplotlib.pyplot as plt
%matplotlib inline

# lê o arquivo de dados "network.csv" em um diretório padrão. Nomeie o arquivo de log para "network.csv"
# municipio = pd.read_csv('Base_MUNIC_2020.csv')
ifood = pd.read_csv('ifood.csv', sep=";")

# Tipos dos dados
ifood.dtypes

ifood = ifood.astype({'CodMun':object})

# Tipos dos dados
ifood.dtypes

# Formato dos dados
ifood.shape

#ifood.head(30)
ifood.tail()

# Inversão da forma de visualização dos dados
ifood.T

ifood.groupby(['CodMun', 'categoria', 'nome_restaurante', 'faixa_preco']).sum()

cp_ifood = ifood.copy()

cp_ifood.head()

# df_cp = cp_ifood.drop(['CodMun', 'preco_minimo_pedido', 'nome_restaurante', 'faixa_preco','url'], axis=1)

df_cp = cp_ifood.drop(['tempo_entrega','preco_minimo_pedido', 'nome_restaurante', 'faixa_preco','url'], axis=1)

df_cp.head()

df_grupos = df_cp.groupby(['categoria'],sort=True).count().head(20)
# df_grupos = df_cp.groupby(['categoria'],sort=False).count().head(20)

df_grupos

df_grupos.plot(kind='barh', figsize=(8,8))

cp_ifood['categoria'].value_counts()

### 1. Gráfico de Barras
import matplotlib.pyplot as plt
import seaborn as sns
# sns.set_theme()
# Load the example flights dataset and convert to long-form
flights_long = sns.load_dataset("flights")
flights = flights_long.pivot("month", "year", "passengers")
# Draw a heatmap with the numeric values in each cell
f, ax = plt.subplots(figsize=(9, 6))
sns.heatmap(flights, annot=True, fmt="d", linewidths=.5, ax=ax)

import seaborn as sns
import matplotlib.pyplot as plt
# sns.set_theme(style="whitegrid")
# Load the example diamonds dataset
diamonds = sns.load_dataset("diamonds")
# Draw a scatter plot while assigning point colors and sizes to different
# variables in the dataset
f, ax = plt.subplots(figsize=(6.5, 6.5))
sns.despine(f, left=True, bottom=True)
clarity_ranking = ["I1", "SI2", "SI1", "VS2", "VS1", "VVS2", "VVS1", "IF"]
sns.scatterplot(x="carat", y="price",
                hue="clarity", size="depth",
                palette="ch:r=-.2,d=.3_r", 
                hue_order=clarity_ranking,
                sizes=(1, 8), linewidth=0,
                data=diamonds, ax=ax)

import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
# sns.set_theme(style="white", context="talk")
rs = np.random.RandomState(8)
# Set up the matplotlib figure
f, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(7, 5), sharex=True)
# Generate some sequential data
x = np.array(list("ABCDEFGHIJ"))
y1 = np.arange(1, 11)
sns.barplot(x=x, y=y1, palette="rocket", ax=ax1)
ax1.axhline(0, color="k", clip_on=False)
ax1.set_ylabel("Sequencial")
# Center the data to make it diverging
y2 = y1 - 5.5
sns.barplot(x=x, y=y2, palette="vlag", ax=ax2)
ax2.axhline(0, color="k", clip_on=False)
ax2.set_ylabel("Divergente")
# Randomly reorder the data to make it qualitative
y3 = rs.choice(y1, len(y1), replace=False)
sns.barplot(x=x, y=y3, palette="deep", ax=ax3)
ax3.axhline(0, color="k", clip_on=False)
ax3.set_ylabel("Qualitativo")
# Finalize the plot
sns.despine(bottom=True)
plt.setp(f.axes, yticks=[])
plt.tight_layout(h_pad=2)

import seaborn as sns
import matplotlib.pyplot as plt
# sns.set_theme(style="whitegrid")
# Initialize the matplotlib figure
f, ax = plt.subplots(figsize=(6, 15))
# Load the example car crash dataset
crashes = sns.load_dataset("car_crashes").sort_values("total", ascending=False)
# Plot the total crashes
sns.set_color_codes("pastel")
sns.barplot(x="total", y="abbrev", data=crashes,
            label="Total", color="b")
# Plot the crashes where alcohol was involved
sns.set_color_codes("muted")
sns.barplot(x="alcohol", y="abbrev", data=crashes,
            label="Alcoolizados", color="b")
# Add a legend and informative axis label
ax.legend(ncol=2, loc="lower right", frameon=True)
ax.set(xlim=(0, 24), ylabel="Estados Americanos",
       xlabel="Colisões de automóveis por bilhão de milhas")
sns.despine(left=True, bottom=True)

# Importar a biblioteca
from PIL import Image
import ipywidgets as widgets
import IPython.display as display
import matplotlib.pyplot as plt
%matplotlib inline

# Carregar a imagem
img = Image.open("peixe.jpg")

# Mostrar a imagem local
img

# Mostrar a imagem no aplicativo padrão
img.show()

# Tipo da Imagem
print(img.mode)

# Formato da Imagem
print("Formato = ", img.format)

# Tamanho da Imagem
print(img.size)

# De novo o tamanho da Imagem com um texto melhor
print("Tamanho = ", img.size)

# De novo o tamanho da Imagem com um texto muito melhor
print("Lagura = ", img.size[0])
print("Altura = ", img.size[1])
print("Imagem possui = ", img.size[0], " x ", img.size[1], " pixels")

# Rotacionando uma imagem
grau = int(input("Quantos graus para rotacionar a imagem ?"))
rota_img = img.rotate(grau)
rota_img

# Redimensionar a imagem
print("Imagem possui = ", img.size[0], " x ", img.size[1], " pixels")
largura = int(input("Qual a nova largura da imagem ?"))
altura =  int(input("Qual a nova altura da imagem ?"))
tamanho_novo = (largura, altura)
resize_img = img.resize(tamanho_novo)

if largura == 1000:
    if altura == 100:
        print()
        print("Virou uma manjuba !!!!!!!!")
        print("Imagem possui = ", largura, " x ", altura, " pixels")
resize_img

# Gravando a manjuba
tamanho = (1000, 100)
img = Image.open("peixe.jpg")
manjuba = img.resize(tamanho, resample = Image.BILINEAR)

manjuba.save("manjuba.jpg")

# Abrir a foto da manjuba
img1 = Image.open("manjuba.jpg")
print("Novo tamanho agora como manjuba = ", img1.size[0], " x ", img1.size[1], " pixels")
img1

### Carregar de novo a imagem
img = Image.open("peixe.jpg")
tamanho_novo = (480, 320)
img = img.resize(tamanho_novo)
img

# Retirar a iluminação da imagem

#tamanho_novo = (480, 320)
#img = img.resize(tamanho_novo)
with img as imgnova:
    img1 = img.convert("L") #Luminancia
img1

# Crie um filtro de classificação.
# O filtro de classificação classifica todos os pixels em uma janela de determinado tamanho e retorna o valor de classificação.
from PIL import ImageFilter

# Carregar a imagem novamente
img = Image.open("peixe.jpg")

# Aplicar o filtro de Classificação
out = img.filter(ImageFilter.RankFilter(size=15, rank=3))

# Gravar um arquivo de saída
out.save("out.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)

# Crie um filtro mínimo. Escolhe o valor de pixel mais baixo em uma janela com o tamanho fornecido.
from PIL import ImageFilter
out1 = img.filter(ImageFilter.MinFilter(size=5))

# Gravar um arquivo de saída
out1.save("out1.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out1.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)

# Crie um filtro de modo. Escolhe o valor de pixel mais frequente em uma imagem delimitada com o tamanho fornecido.
# Os valores de pixel que ocorrem apenas uma ou duas vezes são ignorados;
# se nenhum valor de pixel ocorrer mais de duas vezes, o valor de pixel original será preservado.
out2 = img.filter(ImageFilter.ModeFilter(size=15))

# Gravar um arquivo de saída
out2.save("out2.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out2.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)

# Filtro para borrar imagem borrada
from PIL import ImageFilter

out3 = img.filter(ImageFilter.BLUR)

# Gravar um arquivo de saída
out3.save("out3.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out3.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=400, height=300)
wi2 = widgets.Image(value=img2, format='jpg', width=400, height=300)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)

# Filtro para contorno
from PIL import ImageFilter

out4 = img.filter(ImageFilter.CONTOUR)

# Gravar um arquivo de saída
out4.save("out4.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out4.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)

# Filtro para EDGE Enhance
from PIL import ImageFilter

out5 = img.filter(ImageFilter.EDGE_ENHANCE)


# Gravar um arquivo de saída
out5.save("out5.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out5.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)

# Filtro para EDGE Enhance More
from PIL import ImageFilter

out6 = img.filter(ImageFilter.EDGE_ENHANCE_MORE)

# Gravar um arquivo de saída
out6.save("out6.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out6.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)

# Filtro para Emboss
from PIL import ImageFilter

out7 = img.filter(ImageFilter.EMBOSS)

# Gravar um arquivo de saída
out7.save("out7.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out7.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)

# Filtro para Find Edges
from PIL import ImageFilter

out8 = img.filter(ImageFilter.FIND_EDGES)

# Gravar um arquivo de saída
out8.save("out8.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out8.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)

# Filtro para SHARPEN. Utilizado para Nitidez.
from PIL import ImageFilter

out9 = img.filter(ImageFilter.SHARPEN)

# Gravar um arquivo de saída
out9.save("out9.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out9.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)

# Filtro para SMOOTH. Para suavizar a imagem.
from PIL import ImageFilter

out10 = img.filter(ImageFilter.SMOOTH)

# Gravar um arquivo de saída
out10.save("out10.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out10.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)

# Filtro para BoxBlur. Utilizado para desfoque de imagens.
from PIL import ImageFilter

out11 = img.filter(ImageFilter.BoxBlur(10))

# Gravar um arquivo de saída
out11.save("out11.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out11.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)

# Filtro para GaussianBlur. É um filtro para desfoque utilizando uma função gaussiana.
from PIL import ImageFilter

out12 = img.filter(ImageFilter.GaussianBlur(radius=5))

# Gravar um arquivo de saída
out12.save("out12.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out12.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=300, height=400)
wi2 = widgets.Image(value=img2, format='jpg', width=300, height=400)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)

# Filtro para Unsharp Masking
# Aplica um desfoque gaussiano a uma cópia da imagem original e a compara com o original.
# Se a diferença for maior do que uma configuração de limite especificada pelo usuário, as imagens serão (de fato) subtraídas.
# O Unsharp Masking de nitidez é uma maneira flexível e poderosa de aumentar a nitidez da imagem.
import matplotlib.pyplot as plt 
out13 = img.filter(ImageFilter.UnsharpMask(radius=20, percent=500, threshold=3))

# Gravar um arquivo de saída
out13.save("out13.jpg")

# Deixar as imagens lado a lado

# Lê imagens de arquivos (ele é binário, pode ser utilizado com o ByteIO), mas assim é mais fácil
img1 = open('peixe.jpg', 'rb').read()
img2 = open('out13.jpg', 'rb').read()

# Cria um widget de imagem. Pode usar o layout de ipywidgets somente com widgets.
# Seta as variáveis da imagem, formato e dimensãon.
wi1 = widgets.Image(value=img1, format='jpg', width=400, height=300)
wi2 = widgets.Image(value=img2, format='jpg', width=400, height=300)

## Colocar lado a lado com o widget HBox
ladoalado = widgets.HBox([wi1, wi2])

# Finamente vamos mostrar
display.display(ladoalado)

# Carregar a imagem novamente
img = Image.open("peixe.jpg")

# Plotar a imagem com os eixos
plt.imshow(img)

# Carregar a imagem novamente
img = Image.open("peixe.jpg")

# Cortar a cabeça do peixe
cropimg = img.crop((500, 100, 700, 400)) 
cropimg

# Manipulando a plotagem da imagem
plt.figure(figsize=(7, 7))
plt.title("Eu quero ser a Dory!!!!")
plt.imshow(img)
plt.axis('off')
plt.show()