def shannon_diversity(data, bins=None, categorical=False, categories=None):
"""
Calculates the Shannon\'s diversity index of data. Helper function for
:py:class:`momepy.Shannon`.
.. math::
\\lambda=\\sum_{i=1}^{R} p_{i}^{2}
Formula adapted from https://gist.github.com/audy/783125
Parameters
----------
data : GeoDataFrame
GeoDataFrame containing morphological tessellation
bins : array, optional
array of top edges of classification bins. Result of binnng.bins.
categorical : bool (default False)
treat values as categories (will not use ``bins``)
categories : list-like (default None)
list of categories
Returns
-------
float
Shannon's diversity index
See also
--------
momepy.Shannon : Calculates the Shannon's diversity index
momepy.Simpson : Calculates the Simpson's diversity index
momepy.simpson_diversity : Calculates the Simpson's diversity index
"""
from math import log as ln
if not categorical:
try:
import mapclassify as mc
except ImportError:
raise ImportError("The 'mapclassify' package is required")
def p(n, N):
"""Relative abundance"""
if n == 0:
return 0
return (float(n) / N) * ln(float(n) / N)
if categorical:
counts = data.value_counts().to_dict()
for c in categories:
if c not in counts.keys():
counts[c] = 0
else:
sample_bins = mc.UserDefined(data, bins)
counts = dict(zip(bins, sample_bins.counts))
N = sum(counts.values())
return -sum(p(n, N) for n in counts.values() if n != 0)
def pretty_fisherjenks_sampled(y, k=5, digits=2):
"""
Return pretty, rounded, Fisher Jenks Sampled classification schemes. Relies on mapclassify.
-----------
Parameters:
y: input vector
k: number of classes
digits: degree of rounding
-----------
Returns: mapclassify object
"""
original = mapclassify.FisherJenksSampled(y, k=k)
accuracies = (-(np.floor(np.log10(original.bins)) - digits)).astype(int)
pretty_bins = [
round(limit, accuracies[i]) for i, limit in enumerate(original.bins)
]
return mapclassify.UserDefined(y, pretty_bins)
def plot_world_map(df):
""" Plot a world map from a data frame """
cases_per_million = df['total_cases_per_million']
scheme = mapclassify.UserDefined(
cases_per_million, bins=[100, 500, 1000, 5000, 10000, 15000, 20000])
gplt.choropleth(
df,
hue=cases_per_million,
edgecolor='white',
linewidth=1,
scheme=scheme,
cmap='Reds',
legend=True,
figsize=(12, 6),
)
plt.title("Total Confirmed COVID-19 Cases Per Million as of 07-09-2020")
# Without this, the world map doesnt load
plt.show()
def plot_choropleth(
d,
key,
*,
scheme=None,
bin_uls=None,
ax=None,
cmap=mpl.cm.viridis_r,
legend=True,
legend_kws=None,
legend_fmt=DEFAULT_LEGEND_FMT,
plot_kws=None,
):
if legend_kws is None:
legend_kws = {}
if plot_kws is None:
plot_kws = {}
if bin_uls is not None:
assert scheme is None, "supply either scheme or bin_uls"
scheme = mapclassify.UserDefined(d[key], bin_uls)
assert scheme is not None
if ax is None:
fig, ax = plt.subplots()
plot_data = d.assign(**{key: scheme.yb})
plot_data.plot(key, cmap=cmap, ax=ax, linewidth=0, **plot_kws)
if legend:
handles = make_legend_handles(scheme, cmap, fmt=legend_fmt)
ax.legend(handles=handles, **legend_kws)
return ax
"data/world_data_administrative_boundaries_country_level.shp")
except Exception as e:
world = gpd.read_file(
"data/world_data_administrative_boundaries_country_level.zip")
# TODO: Make into gifs
# TODO: Make legend have "No Data" for 0
countries_gdf = countries_gdf[['GDLcode', 'geometry']]
countries_gdf.rename(columns={'GDLcode': 'GDLCODE'}, inplace=True)
countries_gdf = countries_gdf.merge(SHDI_first, on='GDLCODE', how='left')
countries_gdf['shdi'].fillna(-1, inplace=True)
scheme = mapclassify.UserDefined(countries_gdf['shdi'],
bins=[
0, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6,
0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 1.0
])
background_color = '#d1e5f0'
missing_color = 'grey'
fig, ax = plt.subplots(
figsize=(20, 10),
facecolor=background_color,
subplot_kw={
'projection': gcrs.Robinson(),
# https://scitools.org.uk/cartopy/docs/latest/crs/projections.html
'facecolor': background_color
})
plt.title('Human Development Index by World Subdivisions',
fontdict={
return np.median(
np.load(
src /
f"YLL_{state}_{district}_phi{phi}_{vax_policy}.npz")
['arr_0'])
except FileNotFoundError:
# return np.nan
return 0
districts = districts_to_run.copy()\
.assign(YLL = districts_to_run.index.map(load_median_YLL))\
.assign(YLL_per_mn = lambda df: df["YLL"]/(df["N_tot"]/1e6))
fig, ax = plt.subplots(1, 1)
scheme = mapclassify.UserDefined(
districts.YLL_per_mn,
[0, 125, 250, 400, 600, 900, 1200, 1600, 2500, 5000, 7500
]) # ~deciles
scheme = mapclassify.UserDefined(
districts.YLL_per_mn,
[0, 600, 1200, 2000, 2400, 3000, 3600, 4000, 4500, 5550, 9000
]) # ~deciles
districts["category"] = scheme.yb
india.join(districts["category"].astype(int))\
.drop(labels = "Andaman And Nicobar Islands")\
.plot(
column = "category",
linewidth = 0.1,
edgecolor = "k",
ax = ax,
legend = True,
categorical = True,
import numpy as np
import pandas as pd
import geopandas as gpd
import matplotlib.pyplot as plt
import matplotlib.colors
import mapclassify
# get coefficient surface w_sh
legend_classes = mapclassify.NaturalBreaks(
gwr_map_2.loc[(~gwr_map_2['w_sh'].isna()), 'w_sh'], k=5)
legend_classes = mapclassify.UserDefined(
gwr_map_2.loc[(~gwr_map_2['w_sh'].isna()), 'w_sh'],
bins=[-5.55, 0, 5.64, 8.93, 12.69])
mapping = dict([(i, s)
for i, s in enumerate(legend_classes.get_legend_classes())])
# plot
fig = plt.figure(figsize=(10, 8))
ax = fig.add_axes([0, 0, 0.95, 0.95])
gwr_map_2.loc[(~gwr_map_2['w_sh'].isna())].assign(cl = legend_classes.yb).plot(column = 'cl', categorical = True,\
k = 6, cmap = 'coolwarm', norm = matplotlib.colors.Normalize(-1.8,3.5),\
linewidth = 0.3,\
alpha = 0.7,\
ax = ax, edgecolor = 'black', legend = True,\
legend_kwds = {'loc':'lower left',\
'fontsize': 10,\
'frameon': False,\
'title': 'GWR coefficients\nw_sh\n',\
'title_fontsize': 12,\
'edgecolor': 'gray'})
if ltla_classifier_mode == 'manual':
england.plot(column=c_date.strftime('bin_%m%d'),
ax=ax,
vmin=0,
vmax=len(ltla_classifier_bins) - 1,
cmap=colour_map,
zorder=z)
z += 1
# ltla_classifier_colours = ['#338ed7','#ddfffe','#d9fedf','#f3ff92','#ffa923','#e90418','#ad0620']
# for count,cbin in enumerate(ltla_classifier_bins):
# england.plot(column=('bin%02d' % count) + c_date.strftime('%m%d'),ax=ax,vmin=0,vmax=1,facecolor=ltla_classifier_colours[count],zorder=z)
# z+=1
else:
#Classify the relevant data using mapclassify
classified = mc.UserDefined(
england.get(c_date.strftime('ltla_%m%d')),
ltla_classifier_bins)
classified.plot(england,
ax=ax,
cmap=colour_map,
border_width=0.1,
border_color='#EEEEEE22',
legend=True,
legend_kwds={'loc': 'center left'})
if (plot_risk_weighted_ltla_binned):
england.plot(column=c_date.strftime('rwbin_%m%d'),
ax=ax,
vmin=0,
vmax=len(ltla_classifier_bins) - 1,
cmap=colour_map,
zorder=z)
def test_classify():
# data
link_to_data = examples.get_path('columbus.shp')
gdf = gpd.read_file(link_to_data)
x = gdf['HOVAL'].values
# box_plot
a = classify(x, 'box_plot')
b = mapclassify.BoxPlot(x)
_assertions(a, b)
# EqualInterval
a = classify(x, "EqualInterval", k=3)
b = mapclassify.EqualInterval(x, k=3)
_assertions(a, b)
# FisherJenks
a = classify(x, "FisherJenks", k=3)
b = mapclassify.FisherJenks(x, k=3)
_assertions(a, b)
a= classify(x, "FisherJenksSampled", k=3, pct_sampled=0.5, truncate=False)
b = mapclassify.FisherJenksSampled(x, k=3, pct=0.5,truncate=False)
_assertions(a, b)
# headtail_breaks
a = classify(x, 'headtail_breaks')
b = mapclassify.HeadTailBreaks(x)
_assertions(a, b)
# quantiles
a = classify(x, 'quantiles',k=3)
b = mapclassify.Quantiles(x, k=3)
_assertions(a, b)
# percentiles
a = classify(x, 'percentiles', pct=[25,50,75,100])
b = mapclassify.Percentiles(x, pct=[25,50,75,100])
_assertions(a, b)
#JenksCaspall
a = classify(x, 'JenksCaspall', k=3)
b = mapclassify.JenksCaspall(x, k=3)
_assertions(a, b)
a = classify(x, 'JenksCaspallForced', k=3)
b = mapclassify.JenksCaspallForced(x, k=3)
_assertions(a, b)
a = classify(x, 'JenksCaspallSampled', pct_sampled=0.5)
b = mapclassify.JenksCaspallSampled(x, pct=0.5)
_assertions(a, b)
# natural_breaks, max_p_classifier
a = classify(x, 'natural_breaks')
b = mapclassify.NaturalBreaks(x)
_assertions(a, b)
a = classify(x, 'max_p', k=3, initial=50)
b = mapclassify.MaxP(x, k=3, initial=50)
_assertions(a, b)
# std_mean
a = classify(x, 'std_mean', multiples=[-1,-0.5,0.5,1])
b = mapclassify.StdMean(x, multiples=[-1,-0.5,0.5,1])
_assertions(a, b)
# user_defined
a = classify(x, 'user_defined', bins=[20, max(x)])
b = mapclassify.UserDefined(x, bins=[20, max(x)])
_assertions(a, b)
