# Lectura de datos y visualización de gráficos
import pandas as pd
import seaborn as sns

# Para interpretar fechas
from datetime import datetime

#Para controlar las propiedades de nuestros gráficos
import matplotlib.pyplot as plt

# Para visualizar imagenes
import matplotlib.cbook as cbook
from matplotlib.pyplot import imread

# Para visualizar mapas usando leaflet
from ipyleaflet import *

def parseDatetime(x):
    return datetime.strptime(x, "%Y-%m-%d %H:%M:%S")

parsedate = lambda x: parseDatetime(x)

crimeData = pd.read_csv(\
    filepath_or_buffer="../resources/crime.csv",\
    header=0,\
    names=[\
        'Dc_Dist',\
        'Psa',\
        'Dispatch_Date_Time',\
        'Dispatch_Date',\
        'Dispatch_Time',\
        'Hour',\
        'Dc_Key',\
        'Location_Block',\
        'UCR_General',\
        'Text_General_Code',\
        'Police_Districts',\
        'Month',\
        'Lon',\
        'Lat'\
    ],\
    dtype={\
        'Dc_Dist':str,\
        'Psa':str,\
        'Dispatch_Date_Time':str,\
        'Dispatch_Date':str,\
        'Dispatch_Time':str,\
        'Hour':float,\
        'Dc_Key':str,\
        'Location_Block':str,\
        'UCR_General':str,\
        'Text_General_Code':str,\
        'Police_Districts':str,\
        'Month':str,\
        'Lon':float,\
        'Lat':float\
    },\
    parse_dates=["Dispatch_Date_Time"],\
    date_parser=parsedate\
)

crimeData.head()

# Cantidad de crímenes en cada categoría
crimesCountedByType = crimeData.Text_General_Code\
    .value_counts()

crimesCountedByType.head()

# Seteamos el tamaño del gráfico
plt.subplots(figsize=(10, 10))

g = sns.barplot(x=crimesCountedByType.index.tolist(), y=crimesCountedByType.values);

# Hacemos que la leyenda sea mas facil de leer
g.set_xticklabels(rotation=90, labels=crimesCountedByType.index.tolist(), fontsize=12);

# Cantidad de crímenes bajo categorías bien definidas
unidentifiedCrimes = crimesCountedByType\
    .drop("All Other Offenses")\
    .drop("Other Assaults")\
    .sum()

# Cantidad de crímenes bajo las categorías de "Otros"
identifiedCrimes = crimesCountedByType\
    .drop("Thefts")\
    .drop("Vandalism/Criminal Mischief")\
    .drop("Theft from Vehicle")\
    .drop("Narcotic / Drug Law Violations")\
    .drop("Fraud")\
    .drop("Recovered Stolen Motor Vehicle")\
    .drop("Burglary Residential")\
    .drop("Aggravated Assault No Firearm")\
    .drop("DRIVING UNDER THE INFLUENCE")\
    .drop("Robbery No Firearm")\
    .drop("Motor Vehicle Theft")\
    .drop("Robbery Firearm")\
    .drop("Disorderly Conduct")\
    .drop("Aggravated Assault Firearm")\
    .drop("Burglary Non-Residential")\
    .drop("Weapon Violations")\
    .drop("Other Sex Offenses (Not Commercialized)")\
    .drop("Prostitution and Commercialized Vice")\
    .drop("Rape")\
    .drop("Vagrancy/Loitering")\
    .drop("Arson")\
    .drop("Liquor Law Violations")\
    .drop("Forgery and Counterfeiting")\
    .drop("Embezzlement")\
    .drop("Public Drunkenness")\
    .drop("Homicide - Criminal")\
    .drop("Offenses Against Family and Children")\
    .drop("Gambling Violations")\
    .drop("Receiving Stolen Property")\
    .drop("Homicide - Justifiable")\
    .drop("Homicide - Gross Negligence")\
    .sum()

# Calculo de la relación porcentual
100.0 * identifiedCrimes / (identifiedCrimes + unidentifiedCrimes)
>> 31.95938920186576

# Serie de datos con el conteo de crímenes
crimesGroupByType = pd.Series(crimeData\
    .Text_General_Code\
    .value_counts()\
).reset_index()

# Renombramos las columnas
crimesGroupByType.rename(columns = {\
    'Text_General_Code': 'Total',\
    'index': 'Category'
    },\
    inplace=True\
)

# Seteamos el índice en la columna de categorías
crimesGroupByType.set_index("Category", inplace=True)

# Sumamos la cantidades para obtener el total entre todos las categorías
totalCrimes = crimesGroupByType.Total.sum()

# Calculamos el porcentaje de crímenes por categoría
meanCrimesInCategory = crimesGroupByType\
    .Total\
    .apply(lambda totalInCategory: (100.0 * totalInCategory / totalCrimes))

plt.subplots(figsize=(10, 10))

g = sns.barplot(x=meanCrimesInCategory.index.tolist(), y=meanCrimesInCategory.values);

g.set_xticklabels(rotation=90, labels=meanCrimesInCategory.index.tolist(), fontsize=12);

sns.heatmap(crimesGroupByType)

# Interpretamos la columna de mes usando datetime
crimeData.Month = crimeData\
    .Month\
    .apply(lambda givenMonth: datetime.strptime(givenMonth, "%Y-%m"));

# Mapeamos la columna al año que indica
crimesByYears = crimeData\
    .Month\
    .map(lambda x: x.year)\
    .value_counts()

# Echamos un vistazo al resultado
crimesByYears

# Con el parámetro log, indicamos a seaborn que use una
g = sns.barplot(\
    y=crimesByYears.index.tolist(),\
    x=crimesByYears.values,\
    log=True\
);

# Rotamos las etiquetas para hacer mas facil la lectura
g.set_xticklabels(\
    rotation=90,\
    labels=crimesByYears.index.tolist(),\
    fontsize=12\
);

100.0 * crimesByYears[2016] / crimesByYears[2006]
>> 72.03297054375838

# Sacamos los registros sin latitud y longitud
totalCrimes = crimeData.dropna().shape[0]

# Hacemos una ventana de los datos
crimeDataSample = crimeData.sample(totalCrimes // 2)

# Tomamos la ubicación geográfica
lats = (crimeDataSample.Lat * 10e4)
longs = (crimeDataSample.Lon * 10e4)

sns.scatterplot(y=lats, x=longs, alpha=0.1, s = 2, legend = False)

# Generamos una mascara de los crímenes en el año 2016
recentCrimesMask = crimeData.Month.map(lambda x: x.year) == 2016

# Aplicamos la mascara a la data
recentCrimes = crimeData[recentCrimesMask]

# Obtenemos la ubicación correspondiente para cada caso
lats = (recentCrimes.Lat.dropna() * 10e4)
longs = (recentCrimes.Lon.dropna() * 10e4)

# Generamos un DataFrame con estos datos
crimeMap = pd.DataFrame({ 'x': longs, 'y': lats })

# Creamos un gráfico de puntos con scatterplot
sns.scatterplot(y=crimeMap.y, x=crimeMap.x, alpha=0.1, s = 2, legend = False)

# Obtenemos la columna de categorías desde el DataFrame
recentCrimesTypes = recentCrimes.Text_General_Code

# Utilizamos el parámetro hue en scatterplot, para diferenciar los tipos de puntos
sns.scatterplot(\
    y=crimeMap.y,\
    x=crimeMap.x,\
    hue = recentCrimesTypes,\
    alpha=.5,\
    s = 5,\
    legend = False\
)

# Leemos la data que corresponde a la imagen
philadelphiaMap = cbook.get_sample_data(\
    'resources/map.jpeg'\
)

philadelphiaImage = imread(philadelphiaMap)

# Mostramos la imagen
plt.imshow(\
    philadelphiaImage,\
    zorder=0,\
    extent=[0.5, 8.0, 1.0, 7.0]\
)

plt.show()

# Creamos un gráfico de densidad por kernel
sns.kdeplot(\
    lats,\
    longs,\
    cmap="Reds",\
    shade=True,\
    cut=0\
)

# Utilizamos las gráficas para tomar coordenadas de referencia

# Hacemos mascaras de índices que cumplan con estar dentro del centro
longitudeMask = crimeData.Lon.map(lambda x: (x > -75.2) and (x < -75.15)) == 1.0
latitudeMask = crimeData.Lat.map(lambda x: (x > 39.925) and (x < 39.975)) == 1.0

crimesInCenterBlockMask = (longitudeMask) & (latitudeMask)

# Aplicamos la máscara a la data
crimesInCenterBlock = crimeData[crimesInCenterBlockMask]

# Visualizamos el registro con puntos
sns.scatterplot(\
    y = crimesInCenterBlock.Lat, \
    x = crimesInCenterBlock.Lon, \
    hue = crimesInCenterBlock.Text_General_Code, \
    alpha = .5, \
    s = 5, \
    legend = False \
)

# La zona con menos puntos, es el Río Schuylkill

# from ipyleaflet import *

# Creamos un mapa
m = Map(\
    center=(39.925, -75.2),\
    zoom=10,\
    basemap=basemaps.OpenStreetMap.Mapnik\
);

# Creamos un polígono con el cuadro
polygon = Polygon(\
    locations = [\
        (39.925, -75.2),\
        (39.975, -75.2),\
        (39.975, -75.15),\
        (39.925, -75.15)\
    ],\
    color = "green",\
    fill_color = "green"\
);

# Agregamos el polìgono al mapa
m.add_layer(polygon);

# Y lo mostramos
m

crimesInCenterBlock.Text_General_Code\
    .value_counts()\
    .head()

100.0 * (crimesInCenterBlock.count() / crimeData.count())[0]
>> 15.315705855144227

totalCrimes = crimeData.dropna().shape[0]
sns.distplot(crimeData.sample(totalCrimes // 2).Hour);