def __init__(self, positions, colors, colormap=None, nb_steps=12,
weight=None, opacity=None, **kwargs):
super(ColorLine, self).__init__(**kwargs)
self._name = 'ColorLine'
if colormap is None:
cm = LinearColormap(['green', 'yellow', 'red'],
vmin=min(colors),
vmax=max(colors),
).to_step(nb_steps)
elif isinstance(colormap, LinearColormap):
cm = colormap.to_step(nb_steps)
elif isinstance(colormap, list) or isinstance(colormap, tuple):
cm = LinearColormap(colormap,
vmin=min(colors),
vmax=max(colors),
).to_step(nb_steps)
else:
cm = colormap
out = {}
for (lat1, lng1), (lat2, lng2), color in zip(positions[:-1], positions[1:], colors): # noqa
out.setdefault(cm(color), []).append([[lat1, lng1], [lat2, lng2]])
for key, val in out.items():
self.add_child(MultiPolyLine(val, color=key,
weight=weight, opacity=opacity))
def get_color_scale(options, vmin=0, vmax=1):
''' Gets a color array as given by options or builds a linear scale '''
# Check if color list is given, escaping if true
color_array = ViewConfReader.get_attribute_from_chart_spec(options, 'colorArray')
if color_array:
return color_array
scale_def = ViewConfReader.get_attribute_from_chart_spec(
options,
'colorScale',
{'name': 'Blues'}
)
plt = brewer2mpl.get_map(
scale_def.get("name"),
scale_def.get('nature', 'sequential'),
scale_def.get("levels", 5),
reverse=scale_def.get("order", "asc") == 'desc'
)
if "levels" in scale_def:
scale = LinearColormap(
plt.mpl_colors,
vmin=0,
vmax=int(scale_def.get("levels")) - 1
)
return [scale(i) for i in range(scale_def.get("levels"))]
return LinearColormap(
plt.mpl_colors,
vmin=vmin,
vmax=vmax
)
def plot_linestring(geometry, speed_color=None, config=None):
if (type(geometry) == LineString):
geometry = gpd.GeoSeries(geometry)
# set initial coords as first point of first linestring
geometry_ = geometry.geometry[0]
initial_coords = [geometry_.xy[1][0], geometry_.xy[0][0]]
map_ = folium.Map(initial_coords, zoom_start=14)
traces_json = json.loads(geometry.buffer(.00001).to_json())
if (speed_color is not None):
if (np.mean(speed_color) > 1): # if absolute speeds
red_speed, yellow_speed, blue_speed = 0, 25, 40
cmap_caption = 'Speed Km/h'
else: # if relative speed
red_speed, yellow_speed, blue_speed = 0, .4, .8
cmap_caption = 'Relative Speed to Maximum %'
speed_cm = LinearColormap(
['red', 'yellow', 'blue'],
vmin=red_speed,
vmax=blue_speed + (blue_speed * .2), # 20% maxspeed
index=[red_speed, yellow_speed, blue_speed])
speed_cm.caption = cmap_caption
for elem, speed in zip(traces_json['features'], speed_color):
elem['properties']['style'] = {}
elem['properties']['style']['color'] = speed_cm(speed)
elem['properties']['style']['fillOpacity'] = 1
map_.add_child(speed_cm)
traces = folium.features.GeoJson(traces_json)
map_.add_child(traces)
return map_
def getColor(self, feature):
value = self.map_dict.get(feature['properties']['name'])
self.color_scale = LinearColormap(['yellow', 'red'],
vmin=min(self.map_dict.values()),
vmax=max(self.map_dict.values()))
# vmin = 0, vmax = 150)
if value is None:
return '#8c8c8c' # MISSING -> gray
else:
return self.color_scale(value)
def add_colorbar(
self,
colors,
vmin=0,
vmax=1.0,
index=None,
caption="",
categorical=False,
step=None,
**kwargs,
):
"""Add a colorbar to the map.
Args:
colors (list): The set of colors to be used for interpolation. Colors can be provided in the form: * tuples of RGBA ints between 0 and 255 (e.g: (255, 255, 0) or (255, 255, 0, 255)) * tuples of RGBA floats between 0. and 1. (e.g: (1.,1.,0.) or (1., 1., 0., 1.)) * HTML-like string (e.g: “#ffff00) * a color name or shortcut (e.g: “y” or “yellow”)
vmin (int, optional): The minimal value for the colormap. Values lower than vmin will be bound directly to colors[0].. Defaults to 0.
vmax (float, optional): The maximal value for the colormap. Values higher than vmax will be bound directly to colors[-1]. Defaults to 1.0.
index (list, optional):The values corresponding to each color. It has to be sorted, and have the same length as colors. If None, a regular grid between vmin and vmax is created.. Defaults to None.
caption (str, optional): The caption for the colormap. Defaults to "".
categorical (bool, optional): Whether or not to create a categorical colormap. Defaults to False.
step (int, optional): The step to split the LinearColormap into a StepColormap. Defaults to None.
"""
from box import Box
from branca.colormap import LinearColormap
if isinstance(colors, Box):
try:
colors = list(colors["default"])
except Exception as e:
print("The provided color list is invalid.")
raise Exception(e)
if all(len(color) == 6 for color in colors):
colors = ["#" + color for color in colors]
colormap = LinearColormap(colors=colors,
index=index,
vmin=vmin,
vmax=vmax,
caption=caption)
if categorical:
if step is not None:
colormap = colormap.to_step(step)
elif index is not None:
colormap = colormap.to_step(len(index) - 1)
else:
colormap = colormap.to_step(3)
self.add_child(colormap)
def color_scale(color1, color2, value, minValue, maxValue):
"""
@param color1: This parameter is a string that contains a hexadecimal color (format #XXXXXX)
or a valid color (for instance red, orange, yellow, blue) that establishes the first color
in that range of values, the color that will be associated with minValue
@param color2: This parameter is a string that contains a hexadecimal color (format #XXXXXX)
or a valid color (for instance red, orange, yellow, blue) that establishes the second color
in that range of values the color that will be associated with maxValue
@param value: This parameter is a number, the value we have to paint with a color between
color1 and color2 and that has to be between minValue and maxValue
@param minValue: This parameter is a number, the lowest value possible within this range
we are defining
@param maxValue: This parameter is a number, the highest value possible within this range
we are defining
@return: LinearColorMap object
Basically this builds an object where we build a color scale between two colors
In minValue we indicate the value that represents color1 and in maxValue we indicate
the value that represents color2 and we build a segment where the color of each
value has a color according to that scale of value
When we use it as a function using the parameter "value" we return the corresponding
color for that value. We will use this function to color our map
"""
return LinearColormap([color1, color2], vmin=minValue,
vmax=maxValue)(value)
def __init__(self, max_value):
"""
Initialize encode
Args:
max_value (float): maximum value for encoded features
"""
self.cm = LinearColormap(["green", "yellow", "red"],
vmin=0,
vmax=max_value)
def color_scale(color1: str, color2: str, value: float, min_value: float,
max_value: float) -> LinearColormap:
"""
:param color1: This parameter is a string that contains a hexadecimal color (format #XXXXXX)
or a valid color (for instance red, orange, yellow, blue) that establishes the first color
in that range of values, the color that will be associated with minValue
:param color2: This parameter is a string that contains a hexadecimal color (format #XXXXXX)
or a valid color (for instance red, orange, yellow, blue) that establishes the second color
in that range of values the color that will be associated with maxValue
:param value: This parameter is a number, the value we have to paint with a color between
color1 and color2 and that has to be between minValue and maxValue
:param min_value: This parameter is a number, the lowest value possible within this range
we are defining
:param max_value: This parameter is a number, the highest value possible within this range
we are defining
:return: LinearColorMap object
"""
return LinearColormap([color1, color2], vmin=min_value,
vmax=max_value)(value)
def map_points_circles(df, feature, date):
print(feature.title(), 'at time:', date)
# Create a map
this_map = Map(prefer_canvas=True)
# Check for the inputs to be on the dataframe
# Getting data
data = df[df['datetime'] == date]
# Create a color map
color_var = str(feature) #what variable will determine the color
cmap = LinearColormap(['blue', 'red'],
vmin=data[color_var].quantile(0.05),
vmax=data[color_var].quantile(0.95),
caption=color_var)
# Add the color map legend to your map
this_map.add_child(cmap)
def plotDot(point):
'''Takes a series that contains a list of floats named latitude and longitude and
this function creates a CircleMarker and adds it to your this_map'''
CircleMarker(location=[point.latitude, point.longitude],
fill_color=cmap(point[color_var]),
fill=True,
fill_opacity=0.4,
radius=40,
weight=0).add_to(this_map)
# Iterate over rows
data.apply(plotDot, axis=1)
# Set the boundaries
this_map.fit_bounds(this_map.get_bounds())
# Show plot
return this_map
def create_state_count_choropleth(df, designation):
'''
This function counts the number of parks per state and stores the
result in a dataframe. Then it creates a linear color map using the
range of parks per state. The function then reads in a GeoJSON file
of the United States and merges this with the parks per state
dataframe. These objects are then used to create a choropleth map
of the United States with state color based on the number of parks
in that state. If there are no parks in a state, it will be gray.
Parameters
----------
df : Pandas DataFrame
DataFrame of all parks to add to the map.
designation : str
Designation of parks in the dataframe.
Returns
-------
map : Folium map object
Folium map with choropleth color added.
'''
# Create a two-column dataframe of state and a count of the number
# of parks in that state.
state_list = df['states'].apply(lambda x: x.split(','))
state_list = reduce(operator.add, state_list)
parks_per_state = (pd.DataFrame.from_dict(Counter(state_list),
orient='index').reset_index())
parks_per_state = (parks_per_state.rename(columns={
'index': 'state',
0: 'park_count'
}))
# Create the color map.
color_scale = LinearColormap(['yellow', 'green', 'blue'],
vmin=parks_per_state['park_count'].min(),
vmax=parks_per_state['park_count'].max())
color_scale.caption = (
"Number of parks per state ({})".format(designation))
# Create a dataframe from the json file using GeoPandas.
df_geo = gpd.read_file('_reference_data/us-states.json')
df_geo = df_geo.merge(parks_per_state,
left_on='id',
right_on='state',
how='left').fillna(0)
# Find the center of the data and create an empty map.
centroid = df_geo.geometry.centroid
map = folium.Map(location=[centroid.y.mean(),
centroid.x.mean()],
zoom_start=3)
# Color each state based on the number of parks in it.
folium.GeoJson(
data=df_geo[['geometry', 'name', 'state', 'park_count']],
name='United States of America',
style_function=lambda x: {
'fillColor': get_state_color(x, parks_per_state, color_scale),
'fillOpacity': 0.7,
'color': 'black',
'line_opacity': 0.5,
'weight': 0.5
},
tooltip=folium.features.GeoJsonTooltip(fields=[
'name',
'park_count',
],
aliases=["State", "# of parks"
])).add_to(map)
# Add color scale legend.
map.add_child(color_scale)
# Save choropleth to file.
map.save(set_filename('choropleth_map', 'html', designation))
return map
feq = feq.groupby('neighbourhood')['price'].mean().sort_values(ascending=True)
feq.plot.barh(figsize=(10, 8), color='b', width=1)
plt.title("Average daily price for a 2-persons accommodation", fontsize=20)
plt.xlabel('Average daily price (Euro)', fontsize=12)
plt.ylabel("")
plt.show()
adam = gpd.read_file("../input/neighbourhoods.geojson")
feq = pd.DataFrame([feq])
feq = feq.transpose()
adam = pd.merge(adam, feq, on='neighbourhood', how='left')
adam.rename(columns={'price': 'average_price'}, inplace=True)
adam.average_price = adam.average_price.round(decimals=0)
map_dict = adam.set_index('neighbourhood')['average_price'].to_dict()
color_scale = LinearColormap(['yellow', 'red'],
vmin=min(map_dict.values()),
vmax=max(map_dict.values()))
def get_color(feature):
value = map_dict.get(feature['properties']['neighbourhood'])
return color_scale(value)
map3 = folium.Map(location=[52.3680, 4.9036], zoom_start=11)
folium.GeoJson(data=adam,
name='Amsterdam',
tooltip=folium.features.GeoJsonTooltip(
fields=['neighbourhood', 'average_price'],
labels=True,
sticky=False),
'style': {
'color': row['Color']
}
}
}
features.append(feature)
if row["id"] in ["DNK", "FRA", "ITA", "GBR", "GRC"]:
for geometry in compl.get(row["id"]).get("geometries"):
feature_new = dict(feature)
feature_new["geometry"] = geometry
features.append(feature_new)
new_map = folium.Map([50.736455, 17.666], zoom_start=4.5)
TimestampedGeoJson({
'type': 'FeatureCollection',
'features': features
},
period='P1M',
duration='P1M',
add_last_point=True,
auto_play=False,
loop=False,
max_speed=1,
loop_button=True,
date_options='YYYY/MM',
time_slider_drag_update=True).add_to(new_map)
colormap = LinearColormap(color_scale, vmin=0, vmax=bin_edges[-1])
colormap.caption = "Monthly average " + pollutant + " (in µg/m3)"
colormap.add_to(new_map)
new_map.save("../maps/avg_" + pollutant + ".html")
def loadChoroplethWorldCountries(self, filter):
from copy import deepcopy
import folium
from branca.colormap import LinearColormap
self.title = "World Choropleth"
self.filter = deepcopy(filter)
# find states in filtered sightings
countryDict = defaultdict()
minimalSightingList = self.mdiParent.db.GetMinimalFilteredSightingsList(
filter)
for s in minimalSightingList:
# Consider only full species, not slash or spuh or hybrid entries
commonName = s["commonName"]
if "/" not in commonName and "sp." not in commonName and " x " not in commonName:
if self.mdiParent.db.TestSighting(s, filter):
if s["country"] not in countryDict.keys():
countryDict[s["country"]] = [s]
else:
countryDict[s["country"]].append(s)
# check if no sightings were found. Return false if none found. Abort and display message.
if len(countryDict) == 0:
return (False)
countryTotals = defaultdict()
largestTotal = 0
for country in countryDict.keys():
countrySpecies = set()
for s in countryDict[country]:
countrySpecies.add(s["commonName"])
countryTotals[country] = len(countrySpecies)
if len(countrySpecies) > largestTotal:
largestTotal = len(countrySpecies)
# Load the shape of the zone (US counties)
geo_file = self.mdiParent.db.country_geo
#add the country values to the geojson so we can access them for tooltips
for f in geo_file["features"]:
if f["id"] in countryTotals.keys():
f["properties"]["speciesTotal"] = countryTotals[f["id"]]
else:
f["properties"]["speciesTotal"] = 0
countryTotals[f["id"]] = 0
#create color range for map, using the maximum country value found above
colormap = LinearColormap(
colors=[(255, 240, 227), (255, 119, 0)],
index=[0, round(largestTotal * .75)],
vmin=0,
vmax=largestTotal,
)
# Initialize the folium map
choro_map = folium.Map(location=[1, 1], zoom_start=1)
# Configure the chloropleth layer and add to map
folium.GeoJson(geo_file,
style_function=lambda feature: {
'fillColor':
'rgb(240, 240, 240)' if countryTotals[feature['id']]
== 0 else colormap(countryTotals[feature['id']]),
'color':
'black',
'weight':
1,
'fillOpacity':
.8,
'nan_fill_color':
'white'
},
tooltip=folium.features.GeoJsonTooltip(
fields=['name', 'speciesTotal'],
aliases=["Country", "Species"])).add_to(choro_map)
# make the layer control box visible
folium.LayerControl().add_to(choro_map)
# get the html string from the map
html = choro_map.get_root().render()
self.webView.setHtml(html)
return (True)
from branca.colormap import LinearColormap
color_scale = {}
lim1 = df2[[map_param]].rolling(smoothing).mean().fillna(0).describe().iloc[4,
0]
lim2 = df2[[
map_param
]].rolling(smoothing).mean().fillna(0).describe().iloc[[2, 1], 0].sum() * 5 / 3
diff = lim2 - lim1
color_scale = LinearColormap([
'#91db9b',
'yellow',
'red',
],
index=[
max(0, lim1 - diff / 2),
max(0, lim1 - min(lim1 / 2, diff / 2)),
lim2 - diff / 6
])
feature_group5 = folium.FeatureGroup(name='Area of interest', show=True)
def plotDot(point, color):
size = 2
if smoothing:
to_plot = 'smoothedmap'
else:
if map_param == 'SCRIM':
to_plot = 'THRESHOLD1'
fillColours = colours['Colours'].values.tolist()
colours = colours.merge(mostPopularByZIP,
'left').drop_duplicates(subset='Breed Numeric').drop(
['Count', 'ZIP Code'], axis=1)
mostPopularByZIP = mostPopularByZIP.merge(colours, how='left')
#add in seaborn summarized plots to map
dictMPBZ = mostPopularByZIP[['Breed Numeric', 'ZIP Code']]
dictMPBZ = dictMPBZ.reset_index()
dictMPBZ['Breed ZIP'] = dictMPBZ[['Breed Numeric', 'ZIP Code']].values.tolist()
color_scale = LinearColormap(fillColours,
vmin=dictMPBZ['Breed Numeric'].min(),
vmax=dictMPBZ['Breed Numeric'].max())
def get_color(feature):
for i, r in dictMPBZ.iterrows():
if feature['properties']['postalCode'] == r['Breed ZIP'][1]:
return color_scale(r['Breed ZIP'][0])
folium.GeoJson(data='~/DS projects/Dog map/filtered-file.geojson',
style_function=lambda feature: {
'fillColor': get_color(feature),
'fillOpacity': 0.8,
'color': 'black',
'weight': 1,
bands[4] = {'LV3':[5,13], 'LV10':[27,71], 'LTRC':[0.15, 2.0], 'LLTX':[0.6, 0.3], 'LLRD':[10, 20], 'LRRD':[10, 20], 'RCI':[40, 100]}
bands[5] = {'LV3':[7,17], 'LV10':[35,93], 'LTRC':[0.15, 2.0], 'LLTX':[0.6, 0.3], 'LLRD':[10, 20], 'LRRD':[10, 20], 'RCI':[40, 100]}
bands[6] = {'LV3':[8,20], 'LV10':[41,110], 'LTRC':[0.15, 2.0], 'LLTX':[0.6, 0.3], 'LLRD':[10, 20], 'LRRD':[10, 20], 'RCI':[40, 100]}
from branca.colormap import LinearColormap
color_scale = {}
if hier in bands:
if map_param in bands[hier]:
lim1 = bands[hier][map_param][0]
lim2 = bands[hier][map_param][1]
diff = lim2-lim1
if diff > 0:
color_scale = LinearColormap(['#91db9b','yellow','red',], index=[max(0,lim1-diff/2),max(0,lim1-min(lim1/2,diff/2)),lim2-diff/6])
else: #texture
color_scale = LinearColormap(['red','yellow','#91db9b',], index=[lim2+diff/6,lim1+diff/2,max(0,lim1-diff/2),])
#st.write('limits are %s , %s , %s. %s %s' %(max(0,lim1-diff/2),lim1+diff/2,lim2+diff/6, lim1, lim2))
elif map_param == 'SCRIM':
color_scale = LinearColormap(['#91db9b','yellow','red'], index=[0.005,0.05,0.13])
else:
#df_tmp = df3[map_param].append(df4[map_param])
lim1 = df[df['Class']==hier][[map_param]].describe().iloc[4,0]
lim2 = df[df['Class']==hier][[map_param]].describe().iloc[[2,1],0].sum()*5/3
diff = lim2-lim1
color_scale = LinearColormap(['#91db9b','yellow','red',], index=[lim1,lim2-diff/2,lim2-diff/6])
#st.write('limits are %s , %s , %s. %s %s' %( lim1,lim1+diff/6,lim2-diff/6, lim1, lim2))
class WorldMapDisplay():
def __init__(self, countries, cumul_or_diff, which_data):
self.geolocator = Nominatim(
user_agent="Worldmap for Covid-19 studing case")
# ,tiles="cartodbpositron")#,"CartoDB dark_matter")
self.world_map = folium.Map(width=600,
height=400,
location=[48.52, 2.19],
zoom_start=3)
self.countries = sorted(countries)
self.which_data = which_data
p = cc.Parser()
babypandas = (p.getStats(country=self.countries,
type=cumul_or_diff,
which=which_data,
output='pandas'))
babypandascumul = babypandas
babypandascumul['cumul'] = babypandas.groupby(
['country'])['cases'].apply(lambda x: x.cumsum())
mask_date_max = babypandas.groupby(['country'])['date'].max()
babypandascumulmasked_date = babypandascumul['date'].isin(
mask_date_max)
self.data = pd.pivot_table(babypandas,
index='date',
columns='country',
values='cases').reset_index()
if cumul_or_diff == 'cumul':
self.data = pd.pivot_table(babypandascumul,
index='date',
columns='country',
values='cumul').reset_index()
map_data = pd.DataFrame({
'country':
self.countries,
'totcases':
babypandascumul[babypandascumulmasked_date]['cumul'].to_list()
})
self.totalsallcountries = sum(
babypandascumul[babypandascumulmasked_date]['cumul'])
self.maxdeaths = max(
babypandascumul[babypandascumulmasked_date]['cumul'])
self.map_dict = map_data.set_index('country')['totcases'].to_dict()
def LatLong(self, country):
if country != None:
location = self.geolocator.geocode(country)
if location != None:
Lat = location.latitude # , location.longitude)
Long = location.longitude
else:
Lat = float("Nan") # , location.longitude)
Long = float("Nan")
return (Lat, Long)
def DrawPopUpCircle(self):
for coun in self.countries:
filter_data = self.data[['date',
coun]].rename(columns={coun: 'cases'})
tot = self.map_dict[coun]
latlong = self.LatLong(coun)
start_coords = [latlong[0], latlong[1]]
source = pd.DataFrame({
'date': filter_data['date'],
'cases': filter_data['cases'],
})
if sum(filter_data['cases']) != 0:
chart = alt.Chart(source).mark_line().encode(
alt.X('date', axis=alt.Axis(title='Date')),
alt.Y('cases', axis=alt.Axis(title='Cases'))).properties(
title=coun.upper())
vis1 = chart.to_json()
vega = folium.features.VegaLite(vis1,
width='100%',
height='100%')
#
maxrad = 50
circ_mkr = folium.CircleMarker(
location=start_coords,
radius=maxrad * tot / self.totalsallcountries,
color='blue',
fill=True,
fill_color='red',
fillOpacity=1.0,
opacity=1.0,
tooltip=coun,
popup=folium.Popup(max_width=300).add_child(vega))
circ_mkr.add_to(self.world_map)
def drawCountry(self):
folium.GeoJson(
data=
'https://raw.githubusercontent.com/johan/world.geo.json/master/countries.geo.json',
style_function=lambda feature: {
'fillColor': self.getColor(feature),
'caption': 'Total deaths',
'fillOpacity': 0.5,
'weight': 0.5
}).add_to(self.world_map)
def getColor(self, feature):
value = self.map_dict.get(feature['properties']['name'])
self.color_scale = LinearColormap(['yellow', 'red'],
vmin=min(self.map_dict.values()),
vmax=max(self.map_dict.values()))
# vmin = 0, vmax = 150)
if value is None:
return '#8c8c8c' # MISSING -> gray
else:
return self.color_scale(value)
def returnMap(self):
self.drawCountry()
self.DrawPopUpCircle()
colormap = self.color_scale.to_step(len(self.countries))
colormap.caption = self.which_data.upper()
self.world_map.add_child(colormap)
return self.world_map
def geo_map(h2,
map=None,
tiles='stamenterrain',
cmap="wk",
alpha=0.5,
lw=1,
fit_bounds=None,
layer_name=None):
"""Show rectangular grid over a map.
Parameters
----------
h2: physt.histogram_nd.Histogram2D
A histogram of coordinates (in degrees: latitude, longitude)
map : folium.folium.Map
Returns
-------
map : folium.folium.Map
"""
if not map:
latitude = h2.get_bin_centers(0).mean()
longitude = h2.get_bin_centers(1).mean()
zoom_start = 10
map = folium.Map(location=[latitude, longitude], tiles=tiles)
if fit_bounds == None:
fit_bounds = True
geo_json = _bins_to_json(h2)
if not layer_name:
layer_name = h2.name
from branca.colormap import LinearColormap
color_map = LinearColormap(cmap,
vmin=h2.frequencies.min(),
vmax=h2.frequencies.max())
# legend = folium.Html("<div>Legend</div>")
# legend_div = folium.Div("20%", "20%", "75%", "5%")
#
# legend_div.add_to(map)
# legend_div.add_child(legend)
#xx = h2.frequencies.max()
def styling_function(bin):
count = bin["properties"]["count"]
return {
"fillColor": color_map(count),
"color": "black",
"fillOpacity": alpha if count > 0 else 0,
"weight": lw,
# "strokeWidth": lw,
"opacity": alpha if count > 0 else 0,
} # .update(styling)
layer = folium.GeoJson(geo_json,
style_function=styling_function,
name=layer_name)
layer.add_to(map)
if fit_bounds:
map.fit_bounds(layer.get_bounds())
return map
def colorMap_Linear(self,
column1,
column2=None,
threshold_min1=None,
threshold_min2=None,
threshold_max1=None,
threshold_max2=None,
method='linear'):
"""Creates a colormap for the Choropleth map.
Parameters
----------
column1 : Attribute that specifies the fill colour of the Choropleth map
column2 : Attribute that spceifies the border colour of the Choropleth map
Examples
--------
>>> geo.colorMap('Population', 'PopDensity')
"""
if threshold_min1 == None:
threshold_min1 = self.df[column1].min()
if threshold_max1 == None:
threshold_max1 = self.df[column1].max()
self.column1 = column1
self.colormap = LinearColormap(
['#3f372f', '#62c1a6', '#1b425e', '#bbf9d9', '#ffffff'],
vmin=self.df[self.df[column1] >= threshold_min1][column1].min(),
vmax=self.df[
self.df[column1] <= threshold_max1][column1].max()).to_step(
data=self.df[self.df[column1] <= threshold_max1][
self.df[column1] >= 0][column1],
n=5,
method=method)
self.vdict = self.df[self.df[column1] <= threshold_max1][
self.df[column1] >= threshold_min1].set_index(
self.locationcol)[column1]
self.baseMap.map.add_child(self.colormap)
self.baseMap.map.add_child(
BindColormap(
self.baseMap.feature_groups[self.feature_group][self.name],
self.colormap))
if column2 == None:
self.colormap2 = None
else:
if threshold_min2 == None:
threshold_min2 = self.df[column2].min()
if threshold_max2 == None:
threshold_max2 = self.df[column2].max()
self.column2 = column2
self.colormap2 = LinearColormap(
['#3f372f', '#62c1a6', '#1b425e', '#bbf9d9', '#ffffff'],
vmin=self.df[
self.df[column2] >= threshold_min2][column2].min(),
vmax=self.df[self.df[column2] <= threshold_max2]
[column2].max()).to_step(
data=self.df[self.df[column2] <= threshold_max2][
self.df[column2] >= 0][column2],
n=5,
method=method)
self.vdict2 = self.df[self.df[column2] <= threshold_max2][
self.df[column2] >= threshold_min2].set_index(
self.locationcol)[column2]
self.baseMap.map.add_child(self.colormap2)
self.baseMap.map.add_child(
BindColormap(
self.baseMap.feature_groups[self.feature_group][self.name],
self.colormap2))
