def test_matplotlib_contour_to_geojson(self): latrange, lonrange, Z = self.create_grid_data() config = ContourPlotConfig(level_lower=0, level_upper=202, unit='[unit]') figure = plt.figure() ax = figure.add_subplot(111) contours = ax.contour( lonrange, latrange, Z, levels=config.levels, cmap=config.colormap ) contourf = ax.contourf( lonrange, latrange, Z, levels=config.levels, cmap=config.colormap ) ndigits = 3 geojsoncontour.contour_to_geojson( contour=contours, geojson_filepath=self.geojson_file, contour_levels=config.levels, min_angle_deg=config.min_angle_between_segments, ndigits=ndigits, unit=config.unit ) geojsoncontour.contourf_to_geojson( contourf=contourf, geojson_filepath=self.geojson_file_contourf, contour_levels=config.levels, min_angle_deg=config.min_angle_between_segments, ndigits=ndigits, unit=config.unit ) geojsoncontour.contourf_to_multipolygeojson( contourf=contourf, geojson_filepath=self.geojson_file_multipoly, contour_levels=config.levels, min_angle_deg=config.min_angle_between_segments, ndigits=ndigits, unit=config.unit ) self.assertTrue(os.path.exists(self.geojson_file)) self.assertTrue(filecmp.cmp(self.benchmark_geojson_file, self.geojson_file)) os.remove(self.geojson_file) self.assertTrue(os.path.exists(self.geojson_file_contourf)) self.assertTrue(filecmp.cmp(self.benchmark_geojson_file_contourf, self.geojson_file_contourf)) os.remove(self.geojson_file_contourf) self.assertTrue(os.path.exists(self.geojson_file_multipoly)) self.assertTrue(filecmp.cmp(self.benchmark_geojson_file_multipoly, self.geojson_file_multipoly)) os.remove(self.geojson_file_multipoly)
def test_matplotlib_contourf_to_geojson(self): contourf = self.create_contourf() ndigits = 3 geojsoncontour.contourf_to_geojson( contourf=contourf, geojson_filepath=self.geojson_file_multipoly, min_angle_deg=self.config.min_angle_between_segments, ndigits=ndigits, unit=self.config.unit ) self.assertTrue(os.path.exists(self.geojson_file_multipoly)) self.assertTrue(filecmp.cmp(self.benchmark_geojson_file_multipoly, self.geojson_file_multipoly)) os.remove(self.geojson_file_multipoly)
def test_matplotlib_contourf_to_geojson(self): contourf = self.create_contourf() ndigits = 3 geojsoncontour.contourf_to_geojson( contourf=contourf, geojson_filepath=self.geojson_file_multipoly, min_angle_deg=self.config.min_angle_between_segments, ndigits=ndigits, unit=self.config.unit) self.assertTrue(os.path.exists(self.geojson_file_multipoly)) self.assertTrue( filecmp.cmp(self.benchmark_geojson_file_multipoly, self.geojson_file_multipoly)) os.remove(self.geojson_file_multipoly)
def generate_layer_distance(tmp_map, X, Y, Z, ll=0, ul=300, cmap_name='seismic', levels=30): contourf = plt.contourf(X, Y, Z, levels, cmap=cmap_name, alpha=1, vmin=ll, vmax=ul, linestyles='dashed') # Convert matplotlib contourf to geojson geojson = geojsoncontour.contourf_to_geojson(contourf=contourf, stroke_width=0) fg_dist = folium.FeatureGroup(name="Distance", show=False) tmp_map.add_child(fg_dist) # Plot the contour plot on folium folium.GeoJson( geojson, style_function=lambda x: { # 'weight': x['properties']['stroke-width'], 'fillColor': x['properties']['fill'], 'opacity': 0.5, # does not work 'weight': 0.4 }).add_to(fg_dist) return tmp_map
def runmodel(input_date): date = (pd.to_datetime(input_date)).date() modelfilename = 'data/lin_model.sav' scalerfilename = 'data/lin_scaler.sav' lin = pickle.load(open(modelfilename, 'rb')) scaler = pickle.load(open(scalerfilename, 'rb')) testX = build_input(date) testx = testX[['TL1', 'Tmin', 'Tmax', 'd_lm', 'sqrt_dw', 'sqrt_dp']] X = scaler.transform(testx) Y = lin.predict(X) l = len(Y) for i in range(l): if Y[i] < 0: Y[i] = 0 smallY = Y.reshape(101, 101) # y5 = ndimage.zoom(smallY, 5) NN = np.genfromtxt("data/nans100.csv", delimiter=',').transpose() TT = np.multiply(smallY, NN) xx = np.linspace(min(testX['lon']), max(testX['lon']), 101) yy = np.linspace(min(testX['lat']), max(testX['lat']), 101) colors = ['darkgreen', 'green', 'yellow', 'orange', 'red', 'darkred'] vmin = 0 vmax = 50 levels = len(colors) cfig = plt.contourf(xx, yy, TT, levels, alpha=1.0, colors=colors, linestyles='None', vmin=vmin, vmax=vmax) geojson = geojsoncontour.contourf_to_geojson(contourf=cfig, min_angle_deg=0.0, ndigits=5, stroke_width=0.5, fill_opacity=1.0) geomap = folium.Map(location=[41.89, -87.64], zoom_start=13, tiles="stamenterrain") folium.GeoJson(geojson, style_function=lambda x: { 'color': x['properties']['stroke'], 'weight': x['properties']['stroke-width'], 'fillColor': x['properties']['fill'], 'fillOpacity': 0.65 }).add_to(geomap) plugins.Fullscreen(position='topright', force_separate_button=True).add_to(geomap) fname = 'static/' + str(dt.datetime.now()) + '.html' geomap.save(f'flaskapp/' + fname) return fname
def netcdf_to_geojson(ncfile, var, fourth_dim=None): realpath = os.path.realpath(ncfile) name, ext = os.path.splitext(realpath) X, Y, Z, levels, unit = setup(ncfile, var) figure = plt.figure() ax = figure.add_subplot(111) for t in range(len(Z.time)): third = Z.isel(time=t) position = 0 if len(third.dims) == 3: position = len(getattr(third, third.dims[0])) - 1 third = third[position, ] # local min max levels = np.linspace(start=np.nanmin(third), stop=np.nanmax(third), num=20) contourf = ax.contourf(X, Y, third, levels=levels, cmap=plt.cm.viridis) geojsoncontour.contourf_to_geojson( contourf=contourf, geojson_filepath='{}_{}_t{}_{}.geojson'.format( name, var, t, position), ndigits=3, min_angle_deg=None, unit=unit)
def contour_ice(dataarray): """Contour xarray dataarray of ice cover to geojson""" contours = dataarray.plot.contourf(vmin=0, vmax=100, levels=5) ice_json = json.loads(contourf_to_geojson(contourf=contours)) print(ice_json['type']) # Remove land polygons rm_feats = [ f for f in ice_json['features'] if f['properties']['title'] == '<0.00 ' ] for rm in rm_feats: ice_json['features'].remove(rm) print([ np.array(f['geometry']['coordinates']).shape for f in ice_json['features'] ]) geodf_ice = gpd.GeoDataFrame.from_features(ice_json) return geodf_ice
def add_layer(df,text,cc): if cc == 1: colors = ["#FFFFFF","#CCCCFF", "#AAAAFF", "#6666FF","#0000FF"] elif cc == 2: colors = ["#FFFFFF","#FFCCCC", "#FFAAAA", "#FF6666","#FF0000"] elif cc == 3: colors = ["#FFFFFF","#CCFFCC", "#AAFFAA", "#66FF66","#00FF00"] polygon = Polygon(tw) lons = np.asarray(df.long.tolist()) lats = np.asarray(df.lat.tolist()) data = np.asarray(df.EI.tolist()) grid_space = 0.05 global grid_lon, grid_lat grid_lon = np.arange(lons.min()-0.1, lons.max()+0.1, grid_space) grid_lat = np.arange(lats.min()-0.1, lats.max()+0.1, grid_space) OK = OrdinaryKriging(lons, lats, data, variogram_model='gaussian', verbose=False, enable_plotting=False,nlags=20) global z_mesh,x_mesh,y_mesh z_mesh, ss1 = OK.execute('grid', grid_lon, grid_lat) x_mesh, y_mesh = np.meshgrid(grid_lon, grid_lat) shp = x_mesh.shape mtw = np.zeros(shp,dtype=np.float) for i in range(shp[0]): for j in range(shp[1]): point = Point(x_mesh[i][j], y_mesh[i][j]) if not polygon.contains(point): mtw[i][j] = 1 z_mesh = np.ma.masked_where(mtw == 1, z_mesh) contourf = plt.contourf(x_mesh, y_mesh, z_mesh, levels=[-0.2,0.01,0.1,0.2,0.6,1.2], alpha=0.9, colors=colors, linestyles='None', vmin=-0.2, vmax=1.2) global geojson geojson = geojsoncontour.contourf_to_geojson( contourf=contourf, min_angle_deg=3.0, ndigits=5, stroke_width=1, fill_opacity=0.5) # geoj = folium.GeoJson( # geojson, # style_function=lambda x: { # 'color': x['properties']['stroke'], # 'weight': x['properties']['stroke-width'], # 'fillColor': x['properties']['fill'], # 'opacity': 0.6, # }) geoj = 'none' return geoj,geojson
def get_geojsons(self): data_grids = self.__datagrid.get_data_grids() result = [] for data_grid in data_grids: X = data_grid['X'] Y = data_grid['Y'] Z = data_grid['Z'] if self.__method == 'Изолинии': contour = pylab.contour( X, Y, Z, cmap=self.__create_colourmap()) result.append({ 'geojson': geojsoncontour.contour_to_geojson(contour, stroke_width=0.5), 'leadTime': data_grid['leadTime'] }) if self.__method == 'Контур с подписями': contourf = pylab.contourf( X, Y, Z, cmap=self.__create_colourmap()) result.append({ 'geojson': geojsoncontour.contourf_to_geojson(contourf, stroke_width=0.5), 'leadTime': data_grid['leadTime'] }) return result
def __init__(self, df, bw_method=None, weights=None, alpha=0.4, grid=100, number_of_levels=100, ignore_levels=1, cmap=None, epsg=3857, padding=5000.): """Computes the KDE for a given dataset and creates the heatmap. Parameters: df (object): A dataframe with geometries and optionally weights. bw_method (string, optional): The method used to calculate the estimator bandwidth. This can be ‘scott’, ‘silverman’, a scalar constant or a callable. See https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.gaussian_kde.html weights (string): The attribute name of the weights in the dataframe. alpha (float): The alpha blending value, between 0 (transparent) and 1 (opaque) (default: 0.4). grid (int): The number of points in the grid (default: 100). number_of_levels (int): The number of levels in the generated heatmap (default: 100). ignore_levels (int): The number of first levels to ignore (default: 1). cmap (obect|string): A matplotlib Colormap instance or registered colormap name. The colormap maps the level values to colors. (default: A custom colormap blue-green-red weighted to the right.) epsg (int): The EPSG code to reproject the geometries (default: 3857). padding (float, optional): Padding around the MBR in meters. """ self.df = df self.weights = weights self.alpha = alpha self.number_of_levels = number_of_levels self.ignore_levels = ignore_levels self.epsg = epsg # Create the data pois = df.centroid() if epsg is not None: pois.geometry.to_crs(epsg) data = pg.get_coordinates(pois.geometry.to_pygeos().values()) xmin, ymin = data.min(axis=0) - padding xmax, ymax = data.max(axis=0) + padding m1, m2 = data.T x, y = np.mgrid[xmin:xmax:grid * 1j, ymin:ymax:grid * 1j] positions = np.vstack([x.ravel(), y.ravel()]) values = np.vstack([m1, m2]) # Calculate the bandwidth if bw_method is None and weights is None: std = m1.std(ddof=1) n = len(m1) iqr = stats.iqr(m1) bw_method = 0.9 * (min(std, iqr / 1.34) * n**(-0.2)) / std elif bw_method is None and weights is not None: bw_method = 'scotts' # Compute Kernel Density Estimation and levels kde = stats.gaussian_kde(values, bw_method=bw_method, weights=df[weights]) levels = np.reshape(kde(positions).T, x.shape) # Create the colormap if cmap is None: colors = [ '#0000ff', '#00ff00', '#20e000', '#40c000', '#60a000', '#808000', '#a06000', '#c04000', '#e02000', '#ff0000' ] cmap = LinearSegmentedColormap.from_list('BuGrRd', colors, N=100) # Create the filled contour fig, ax = plt.subplots() cset = ax.contourf(x, y, levels, number_of_levels, cmap=cmap, alpha=alpha, antialiased=True) plt.close(fig) # Extract the geojson from contour for i in range(0, ignore_levels): del cset.collections[i] geojson = geojsoncontour.contourf_to_geojson(contourf=cset, ndigits=3, fill_opacity=alpha) geojson = loads(geojson) # Transform to EPSG:4326 geojson = gpd.GeoDataFrame.from_features( geojson['features'], crs="epsg:3857").to_crs(epsg=4326).to_json() # Store computed values self.kde = kde self.grid = (x, y) self.cmap = cmap self.geojson = loads(geojson) self._levels = levels
sigma = [5, 5] z_mesh = sp.ndimage.filters.gaussian_filter(z_mesh, sigma, mode='constant') contourf = plt.contourf(x_mesh, y_mesh, z_mesh, levels, alpha=0.5, colors=colors, linestyles='None', vmin=vmin, vmax=vmax) geojson = geojsoncontour.contourf_to_geojson(contourf=contourf, min_angle_deg=3.0, ndigits=5, stroke_width=1, fill_opacity=0.5) geomap = folium.Map( [data.latitude.mean(), data.longitude.mean()], zoom_start=10, tiles="cartodbpositron") folium.GeoJson(geojson, style_function=lambda x: { 'color': x['properties']['stroke'], 'weight': x['properties']['stroke-width'], 'fillColor': x['properties']['fill'], 'opacity': 0.6, }).add_to(geomap)
def generate_layer_gradient_slope(base_map, X, Y, ll=0, ul=20, cmap_name='Reds', levels=30): # compute gradient X_1d = X.flatten() Y_1d = Y.flatten() elevation = [] for i in trange(0, len(X_1d)): # https://www.opentopodata.org/api/ topo_url = f"http://localhost:5000/v1/eudem25m?locations={Y_1d[i]},{X_1d[i]}&interpolation=cubic" response = requests.get(topo_url) data_topo = response.json() elevation.append(data_topo['results'][0]['elevation']) # https://medium.com/ai-in-plain-english/introduction-to-digital-elevation-map-processing-visualization-in-python-4bb7aa65f2b1 elevation_array = np.array(elevation) elevation_2d = elevation_array.reshape( np.unique(X_1d).size, np.unique(Y_1d).size) dx, dy = np.gradient(elevation_2d) grad_tot = np.hypot(dx, dy) contourf_gradient = plt.contourf(X, Y, grad_tot, levels, cmap=cmap_name, alpha=1, vmin=ll, vmax=ul, linestyles='dashed') # Convert matplotlib contourf to geojson geojson_gradient = geojsoncontour.contourf_to_geojson( contourf=contourf_gradient, stroke_width=0) fg_grad = folium.FeatureGroup(name="Gradient", show=False) base_map.add_child(fg_grad) folium.GeoJson( geojson_gradient, style_function=lambda x: { # 'weight': x['properties']['stroke-width'], 'fillColor': x['properties']['fill'], 'opacity': 0.5, # does not work 'weight': 0.4 }).add_to(fg_grad) # compute slope slopes = np.degrees(np.arctan(np.hypot(dy, dx))) min_slope = np.ceil(np.min(slopes)) max_slope = np.ceil(np.max(slopes)) contourf_slopes = plt.contourf(X, Y, slopes, levels, cmap=cmap_name, alpha=1, vmin=min_slope, vmax=max_slope, linestyles='dashed') # Convert matplotlib contourf to geojson geojson_slopes = geojsoncontour.contourf_to_geojson( contourf=contourf_slopes, stroke_width=0) fg_slope = folium.FeatureGroup(name="Slopes [deg]", show=False) base_map.add_child(fg_slope) folium.GeoJson( geojson_slopes, style_function=lambda x: { # 'weight': x['properties']['stroke-width'], 'fillColor': x['properties']['fill'], 'opacity': 0.5, # does not work 'weight': 0.4 }).add_to(fg_slope) return base_map
import numpy import matplotlib.pyplot as plt import geojsoncontour # Create lat and lon vectors and grid data grid_size = 1.0 latrange = numpy.arange(-90.0, 90.0, grid_size) lonrange = numpy.arange(-180.0, 180.0, grid_size) X, Y = numpy.meshgrid(lonrange, latrange) Z = numpy.sqrt(X * X + Y * Y) n_contours = 20 levels = numpy.linspace(start=0, stop=100, num=n_contours) # Create a contour plot plot from grid (lat, lon) data figure = plt.figure() ax = figure.add_subplot(111) contourf = ax.contourf(lonrange, latrange, Z, levels=levels, cmap=plt.cm.jet) # Convert matplotlib contourf to geojson geojson = geojsoncontour.contourf_to_geojson( contourf=contourf, min_angle_deg=3.0, ndigits=3, stroke_width=2, fill_opacity=0.5 ) print(geojson)
def contourf(lon, lat, data, time_str, timerange_str, **kwargs): """Contour-filled plot using geojsoncontour. Parameters: ----------- lon : array 2-D array of longitudes. Must be same shape as data lat : array 2-D array of latitudes. Must be same shape as data data : array [N, M] Values over which contour fill is drawn time_str : string Valid time for this plot. Included in the placefile title timerange_str : string Valid time range over which to display in GR Other Parameters: ----------------- levels : list, array Number and positions of the contour lines / regions colors : color string (hexademicals) Colors corresponding to each contour-fill level plotinfo : string Brief description of the plot Returns: -------- out : list List of strings, each corresponding to a new line for the placefile """ fig = plt.figure() ax = fig.add_subplot(111) levels = kwargs.get('levels') colors = kwargs.get('colors') plotinfo = kwargs.get('plotinfo', 'None') c = ax.contourf(lon, lat, data, levels, colors=colors) geojson = json.loads( geojsoncontour.contourf_to_geojson(contourf=c, ndigits=8)) out = [] out.append('Title: %s Filled Contour %s\n' % (plotinfo, time_str)) out.append('RefreshSeconds: 60\n') out.append('TimeRange: %s\n' % (timerange_str)) for feature in geojson['features']: rgb = hex2rgb(feature['properties']['fill']) groups = feature['geometry']['coordinates'] for group in groups: out.append('Polygon:\n') first_line = True for item in group[0]: if first_line: COLOR = '%s, %s\n' % (', '.join(rgb), ALPHA) else: COLOR = '' out.append(' %s, %s, %s\n' % (item[1], item[0], COLOR)) first_line = False out.append('End:\n') out.append('\n') plt.close(fig) return out
def build_geojson_contours(data, ax: Axes, manifest: dict): ax.clear() z = data x = z.mesh2d_face_x[:len(z)] y = z.mesh2d_face_y[:len(z)] variable_name = z.name # capture date and convert to datetime dt = datetime64_to_datetime(z.time) # set title on figure ax.set_title(dt.isoformat()) # build json file name output file_name = '{}.json'.format(dt.isoformat()) # convert to numpy arrays z = z.values x = x.values y = y.values # build grid constraints xi = np.linspace(np.floor(x.min()), np.ceil(x.max()), GRID_SIZE) yi = np.linspace(np.floor(y.min()), np.ceil(y.max()), GRID_SIZE) # build delaunay triangles triang = tri.Triangulation(x, y) # build a list of the triangle coordinates tri_coords = [] for i in range(len(triang.triangles)): tri_coords.append( tuple(zip(x[triang.triangles[i]], y[triang.triangles[i]]))) # filter out large triangles large_triangles = [ i for i, t in enumerate(tri_coords) if circum_radius(*t) > MAX_CIRCUM_RADIUS ] mask = [i in large_triangles for i, _ in enumerate(triang.triangles)] triang.set_mask(mask) # interpolate values from triangle data and build a mesh of data interpolator = tri.LinearTriInterpolator(triang, z) Xi, Yi = np.meshgrid(xi, yi) zi = interpolator(Xi, Yi) contourf = ax.contourf(xi, yi, zi, LEVELS, cmap=plt.cm.jet) # create output directory if it doesn't exist output_path = '/tmp/{}'.format(variable_name) if not os.path.exists(output_path): os.makedirs(output_path) # convert matplotlib contourf to geojson geojsoncontour.contourf_to_geojson( contourf=contourf, min_angle_deg=3.0, ndigits=5, stroke_width=2, fill_opacity=0.5, geojson_filepath=os.path.join(output_path, file_name), ) # update the manifest with the geojson output manifest_entry = { 'date': dt.isoformat(), 'path': os.path.join(variable_name, file_name), } if variable_name not in manifest: manifest[variable_name] = {'geojson': []} manifest[variable_name]['geojson'].append(manifest_entry) return contourf
geojson = {} for i, month in enumerate(data.time_stamps()): date = str(month).split('T')[0] datamon = nparr[i] contour = ax.contourf(lons, lats, datamon, transform=proj, cmap=cm, levels=levels, extend='max') result = geojsoncontour.contourf_to_geojson(contourf=contour, ndigits=2, unit='m') geojson[date] = eval(result) #set the legend in one key import matplotlib geojson['legend'] = { 'colors': list([matplotlib.colors.to_hex(rgba) for rgba in cm._lut][0:len(levels)]), 'levels': list(levels) } #write the file import json
def plotDataHTML(df_plot, departamento, ciudad): minlat = np.min(df_plot['lat']) maxlat = np.max(df_plot['lat']) minlon = np.min(df_plot['long']) maxlon = np.max(df_plot['long']) lon = df_plot['long'] lat = df_plot['lat'] meanlon = np.mean(lon) meanlat = np.mean(lat) stdlon = np.std(lon) stdlat = np.std(lat) pro = df_plot['Prob'] ngrid_lon = 200 ngrid_lat = 200 yi = np.linspace(minlat, maxlat, ngrid_lat) xi = np.linspace(minlon, maxlon, ngrid_lon) triang = tri.Triangulation(lon, lat) interpolator = tri.LinearTriInterpolator(triang, pro) Xi, Yi = np.meshgrid(xi, yi) zi = interpolator(Xi, Yi) vmin = np.min(pro) vmax = np.max(pro) sigma = [5, 5] z_mesh = sp.ndimage.filters.gaussian_filter(zi, sigma, mode='constant') colors = [ 'blue', 'royalblue', 'navy', 'pink', 'mediumpurple', 'darkorchid', 'plum', 'm', 'mediumvioletred', 'palevioletred', 'crimson', 'magenta', 'pink', 'red', 'yellow', 'orange', 'brown', 'green', 'darkgreen' ] levels = len(colors) cm = branca.colormap.LinearColormap(colors, vmin=vmin, vmax=vmax).to_step(levels) contf = plt.contourf(Xi, Yi, z_mesh, levels, alpha=0.5, colors=colors, linestyles='None', vmin=vmin, vmax=vmax) geojson = geojsoncontour.contourf_to_geojson(contourf=contf, min_angle_deg=3.0, ndigits=5, stroke_width=1, fill_opacity=0.1) geomap = folium.Map(location=[np.mean(lat), np.mean(lon)], zoom_start=12, tiles="OpenStreetMap") folium.GeoJson(geojson, style_function=lambda x: { 'color': x['properties']['stroke'], 'weight': x['properties']['stroke-width'], 'fillColor': x['properties']['fill'], 'opacity': 0.5, }).add_to(geomap) folium.Circle(location=[minlat, minlon], radius=100, color='crimson', fill=True, fill_color='crimson').add_to(geomap) folium.Circle(location=[maxlat, maxlon], radius=100, color='crimson', fill=True, fill_color='crimson').add_to(geomap) cm.caption = 'Probability' geomap.add_child(cm) plugins.Fullscreen(position='topright', force_separate_button=True).add_to(geomap) geomap.save('Mapa' + departamento + '-' + ciudad + '.html') return ('Mapa' + departamento + '-' + ciudad + '.html') #plotDataHTML(prepareData(dataPath,departamento,ciudad,sexo,edad,mes,dia,hora))
ax = figure.add_subplot(111) contourf = ax.contourf(lon, lat, ssh[num], levels=levels, cmap=plt.cm.coolwarm, extend='both') contourf_trend = ax.contourf(lon, lat, ssh[num] + trend, levels=levels, cmap=plt.cm.coolwarm, extend='both') cbar = plt.colorbar(contourf, ticks=ticks) plt.title('Example') plt.show() geojsonProps = {"time": int(time[num])*1000} out_file_name = '-' + str(len(time) - num) + '.geojson' out_file_name_trend = '-' + str(len(time) - num) + 'trend.geojson' print(int(time[num])*1000) # # Convert matplotlib contour to geojson geojsoncontour.contourf_to_geojson( contourf=contourf, geojson_filepath=out_file_name, ndigits=1, min_angle_deg=7, stroke_width=1, unit='cm', fill_opacity=1.0, geojson_properties=geojsonProps ) geojsoncontour.contourf_to_geojson( contourf=contourf_trend, geojson_filepath=out_file_name_trend, ndigits=1, min_angle_deg=7, stroke_width=1, unit='cm', fill_opacity=1.0, geojson_properties=geojsonProps )
def draw_KDE_Map(i_data,i_geo_map,g1,cl): geomap=i_geo_map #Using Kernel Density Estimation X = i_data[['Longitude', 'Latitude']].values kde = KernelDensity(kernel='gaussian', bandwidth=0.01) kde.fit(X) print("Generating KDE score") log_dens = kde.score_samples(X) #Genrating KDE Contours # Setup debug = False # Setup colormap colors = cl vmin = log_dens.min() vmax =log_dens.max() levels = len(colors) cm = branca.colormap.LinearColormap(colors, vmin=vmin, vmax=vmax).to_step(levels) #The original data x_orig = np.asarray(i_data['Longitude'].values.tolist()) y_orig = np.asarray(i_data['Latitude'].values.tolist()) z_orig = np.asarray(log_dens.tolist()) # Make a grid x_arr = np.linspace(np.min(x_orig), np.max(x_orig), 500) y_arr = np.linspace(np.min(y_orig), np.max(y_orig), 500) x_mesh, y_mesh = np.meshgrid(x_arr, y_arr) # Grid the values z_mesh = griddata((x_orig, y_orig), z_orig, (x_mesh, y_mesh), method='linear') # Gaussian filter the grid to make it smoother sigma = [7,7] z_mesh = sp.ndimage.filters.gaussian_filter(z_mesh, sigma, mode='constant') # Create the contour contourf = plt.contourf(x_mesh, y_mesh, z_mesh, levels, alpha=0.5, colors=colors, linestyles='None', vmin=vmin, vmax=vmax) # Convert matplotlib contourf to geojson geojson = geojsoncontour.contourf_to_geojson( contourf=contourf, min_angle_deg=3.0, ndigits=5, stroke_width=1, fill_opacity=1) # Plot the contour plot on folium g1.add_child(folium.GeoJson( geojson, style_function=lambda x: { 'color': x['properties']['stroke'], 'weight': x['properties']['stroke-width'], 'fillColor': x['properties']['fill'], 'opacity': 0.5, })) geomap.add_child(feature_group) geomap.add_child(g1) #folium.LayerControl().add_to(geomap) # Add the colormap to the folium map cm.caption = 'Kernel Density' geomap.add_child(cm) # Fullscreen mode plugins.Fullscreen(position='topright', force_separate_button=True).add_to(geomap) display(geomap) #geomap.save(f'folium_contour_temperature_map.html') return(geomap)
cmap=cm, levels=levels, extend='max') # Convert matplotlib contour to geojson import geojsoncontour geojson = {} keys = [ '2010-01-15', '2010-02-15', '2010-03-15', '2010-04-15', '2010-05-15', '2010-06-15', '2010-07-15', '2010-08-15', '2010-09-15', '2010-10-15', '2010-11-15', '2010-12-15' ] for i in np.arange(np.shape(data_year)[0]): geojson[keys[i]] = eval( geojsoncontour.contourf_to_geojson(contourf=csf[i], ndigits=2, unit='m')) #set the legend in one key import matplotlib geojson['legend'] = { 'colors': list([matplotlib.colors.to_hex(rgba) for rgba in cm._lut][0:len(levels)]), 'levels': list(levels) } #write the file import json fn = var + '_Column_' + modid + '.geojson' with open(fn, 'w') as f:
dist= np.sqrt((E-x)**2 + (N-y)**2 + (H-z)**2) Lp = Lw - 20*np.log10(dist)-8 return Lp x = np.linspace(Eas-1000, Eas+1000, 10) y = np.linspace(Nor-1000, Nor+1000, 10) X, Y = np.meshgrid(x, y) Z = f(Eas, Nor, Altura, X, Y, Hmap, Lw) Lat, Lon = utm.to_latlon(x, y, Zone, Num) fig, ax = plt.subplots() cs = ax.contourf(Lon, Lat, Z) cbar = fig.colorbar(cs) plt.show() geojson = geojsoncontour.contourf_to_geojson( contourf=cs, ndigits=3, unit='m' ) #print (geojson) with open('myfile1.geojson', 'w') as f: f.write(geojson) f.close()