import os import io from PIL import Image import numpy as np import plotly.express as px import plotly.graph_objects as go import cv2 from itertools import compress from geopandas import points_from_xy from scipy.spatial import Voronoi, voronoi_plot_2d from scipy.spatial.distance import cdist # import matplotlib.pyplot as plt # debugging sep = os.path.sep def extract(lst, i): return [item[i] for item in lst] def extract_coord(lst): return [item.coords[:] for item in lst] def coord_lister(geom): coords = list(geom.exterior.coords) return (coords) # def vor_ver(furthest_pnt, i): # return furthest_pnt[i].vertices def get_plotting_zoom_level_and_center_coordinates_from_lonlat_tuples(longitudes=None, latitudes=None): """Function documentation:\n Basic framework adopted from Krichardson under the following thread: https://community.plotly.com/t/dynamic-zoom-for-mapbox/32658/7 # NOTE: # THIS IS A TEMPORARY SOLUTION UNTIL THE DASH TEAM IMPLEMENTS DYNAMIC ZOOM # in their plotly-functions associated with mapbox, such as go.Densitymapbox() etc. Returns the appropriate zoom-level for these plotly-mapbox-graphics along with the center coordinate tuple of all provided coordinate tuples. """ # Check whether both latitudes and longitudes have been passed, # or if the list lenghts don't match if ((latitudes is None or longitudes is None) or (len(latitudes) != len(longitudes))): # Otherwise, return the default values of 0 zoom and the coordinate origin as center point return 0, (0, 0) # Get the boundary-box b_box = {} b_box['height'] = latitudes.max() - latitudes.min() b_box['width'] = longitudes.max() - longitudes.min() b_box['center'] = (np.mean(longitudes), np.mean(latitudes)) # get the area of the bounding box in order to calculate a zoom-level area = b_box['height'] * b_box['width'] # * 1D-linear interpolation with numpy: # - Pass the area as the only x-value and not as a list, in order to return a scalar as well # - The x-points "xp" should be in parts in comparable order of magnitude of the given area # - The zoom-levels are adapted to the areas, i.e. start with the smallest area possible of 0 # which leads to the highest possible zoom value 20, and so forth decreasing with increasing areas # as these variables are antiproportional zoom = np.interp(x=area, xp=[0, 5 ** -10, 4 ** -10, 3 ** -10, 2 ** -10, 1 ** -10, 1 ** -5], fp=[20, 15, 14, 13, 12, 7, 5]) # Finally, return the zoom level and the associated boundary-box center coordinates return zoom, b_box['center'] def plotly_fig2array(fig, scale): # convert Plotly fig to an array fig_bytes = fig.to_image(format="png", width=2000, height=800, scale=scale) buf = io.BytesIO(fig_bytes) img = Image.open(buf) return np.asarray(img) def beautify_text_placement(shp): """ Function to optimize text placement and size using Voronoi diagram. Arguments: shp -- shape object """ num_area = len(shp) polygons_coord = shp.geometry.apply(coord_lister) furthest_pnt = [None] * num_area voronoi_ori = [None] * num_area for i, points in enumerate(polygons_coord): voronoi_ori[i] = Voronoi(points, furthest_site=False) furthest_pnt[i] = voronoi_ori[i].vertices voronoi_nodes = [None] * num_area leccc = [None] * num_area # get voronoi nodes that is inside the polygon. for i in range(num_area): voronoi_nodes[i] = points_from_xy(extract(furthest_pnt[i], 0), extract(furthest_pnt[i], 1)) voronoi_nodes_if_inside = shp.geometry[i].contains(voronoi_nodes[i]) voronoi_nodes[i] = list(compress(voronoi_nodes[i], voronoi_nodes_if_inside)) leccc[i] = [item for sublist in extract_coord(voronoi_nodes[i]) for item in sublist] dist = [None] * num_area for i, points in enumerate(polygons_coord): # explaining this mess : I need to get the LEC from candidate I got before, but the thing is, # cdist from scipy only accepts exact dimension with array like object, # which means I need to explicitly set the shape of ndarray, convert list of points into ndarray dist[i] = cdist(np.array([list(item) for item in points]), np.array([list(item) for item in leccc[i]])) lecc = [None] * num_area lecc_dist = [None] * num_area for i in range(num_area): voronoi_nodes_dist = [None] * (dist[i].shape[1]) for j in range(dist[i].shape[1]): voronoi_nodes_dist[j] = min(dist[i][:, j]) lecc_ind = np.argmax(voronoi_nodes_dist) lecc[i] = leccc[i][lecc_ind] lecc_dist[i] = np.max(voronoi_nodes_dist) return lecc, lecc_dist def choropleth_chart(shp, df, title, save_dir, colorscheme="BuGn", show_legend=True, unit='', adaptive_legend_font_size=False, geo_annot_scale = 1500, font="Open Sans", scale=4, save=True): f""" shp : geopandas datastream from .shp, .shx and .dbf must exist in the same folder df : single column of pandas DataFrame or any other iterable, height must be the number of object of shp title : title of the chart save_dir : save directory from 'figure/save_dir.png' colorscheme : either string of predefined plotly colorscheme or your colorscheme that is iterate of colors show_legend : Boolean, self explainatory adaptive_legend_font_size : legend of regions become adaptive using voronoi algorithm, asserting the biggest annotation adaptive to the size of the region If false, there will be no annotation over region This, takes some time and could be improved if you could simplify polygons, which is not implemented. font : Defaults to the default plotly font(Open Sans) if None. Type font name string if you need. Execute font_names.py if you want to see the names of the font that python env recognizes. scale : the larger the better save : Boolean, default is True. To save or not to save. """ # TODO add more settings num_area = len(shp) cent_pnt = [None] * num_area for i, cent in enumerate(shp.centroid): cent_pnt[i] = [cent.x, cent.y] cent_map_x = sum(extract(cent_pnt, 0)) / num_area cent_map_y = sum(extract(cent_pnt, 1)) / num_area lecc = None lecc_dist = None if adaptive_legend_font_size: lecc, lecc_dist = beautify_text_placement(shp) # draw the choropleth fig = px.choropleth( # draw shp map shp.set_index("EMD_KOR_NM"), locations=shp.index, # names geojson=shp.geometry, # geojson shape color=df, # a row vector of data color_continuous_scale=colorscheme, center=dict(lat=cent_map_y, lon=cent_map_x), range_color=[0, max(df)], ) fig.update_coloraxes( colorbar=dict( title=dict( text="", font=dict( size=30 ), ), xanchor="left", x=0.235, tickfont=dict( size=20 ), # tickformat=".0%" # put tickformat for later uses? ), ) if show_legend: if adaptive_legend_font_size: annotation_text_size = np.multiply(lecc_dist, geo_annot_scale) fig.add_trace( go.Scattergeo( # draw region names based on lat and lon lat=extract(lecc, 1), lon=extract(lecc, 0), # lat=cent_pnt_y, lon=cent_pnt_x, marker={ "size": [0] * num_area, }, mode="text", name="", text=shp["EMD_KOR_NM"].values, textposition=["middle center"] * num_area, textfont={ # "color": ["Black"] * num_area, "family": [f"{font}"] * num_area, "size": annotation_text_size, } ) ) else: annotation_text_size = [40] * num_area fig.add_trace( go.Scattergeo( # draw region names based on lat and lon lat=extract(cent_pnt, 1), lon=extract(cent_pnt, 0), # lat=cent_pnt_y, lon=cent_pnt_x, marker={ "size": [0] * num_area, }, mode="text", name="", text=shp["EMD_KOR_NM"].values, textposition=["middle center"] * num_area, textfont={ # "color": ["Black"] * num_area, "family": [f"{font}"] * num_area, "size": annotation_text_size, } ) ) # testing with more annotation, such as putting numbers. # fig.add_trace(go.Scattergeo( # # draw region names based on lat and lon # lat=extract(lecc, 1), lon=extract(lecc, 0), # # lat=cent_pnt_y, lon=cent_pnt_x, # marker={ # "size": [0] * num_area, # }, # mode="text", # name="", # text=df, # textposition=["bottom center"] * num_area, # textfont={ # "color": ["Black"] * num_area, # "family": ["Open Sans"] * num_area, # "size": annotation_text_size*0.6, # } # )) fig.update_traces(marker_line_width=3, marker_line_color='white') fig.update_layout(margin={"r": 0, "t": 0, "l": 0, "b": 0}) fig.update_annotations(showarrow=False, visible=True) fig.update_geos(fitbounds="locations", visible=False) fig.update_layout( legend=dict( yanchor="top", y=0.99, xanchor="left", x=0.01 ) ) fig.update_layout( title_text=f"{title}", ) fig.update_layout( font=dict({'family': f'{font}'}) ) fig.update_layout( coloraxis_colorbar=dict( title=f"단위 : {unit}", ) ) # fig.show() # debug if save: # slicing static image because there is no way to adjust geojson object there. img = plotly_fig2array(fig, scale) img = img[:, 460*scale : 1500*scale] p = f"{save_dir}" cv2.imwrite(p, cv2.cvtColor(img, cv2.COLOR_RGB2BGR)) fig.update_layout( title=dict( yanchor="top", y=0.98, xanchor="left", x=0.32, font_size=40, font_color="Black" ), ) print(f"saved at : {p}") else: return fig