def create_geojson(self, filepath, min_zoom=0, max_zoom=12, stroke_width=1, levels=[], norm=None): figure = Figure(frameon=False) FigureCanvas(figure) ax = figure.add_subplot(111) # contours = plt.contourf(lonrange, latrange, Z, levels=levels, cmap=plt.cm.plasma) contours = ax.contour(self.lonrange, self.latrange, self.Z, levels=levels, norm=norm, cmap=plt.cm.jet, linewidths=3) ndigits = len(str(int(1.0 / self.config.stepsize_deg))) + 1 logger.info('converting contour to geojson file: ' + filepath) geojsoncontour.contour_to_geojson( contour=contours, geojson_filepath=filepath, contour_levels=levels, min_angle_deg=self.config.min_angle_between_segments, ndigits=ndigits, unit='min', stroke_width=stroke_width)
def create_geojson(self, filepath, stroke_width=1, levels=[], norm=None): figure = Figure(frameon=False) FigureCanvas(figure) ax = figure.add_subplot(111) colormap = plt.cm.jet contours = ax.contourf(self.lonrange, self.latrange, self.Z, levels=levels, cmap=colormap) contours = ax.contour(self.lonrange, self.latrange, self.Z, levels=levels, norm=norm, cmap=colormap, linewidths=1) ndigits = len(str(int(1.0 / self.config.stepsize_deg))) + 1 geojsoncontour.contour_to_geojson( contour=contours, geojson_filepath=filepath, contour_levels=levels, min_angle_deg=self.config.min_angle_between_segments, ndigits=ndigits, unit='min', stroke_width=stroke_width)
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_contour_to_geojson_none_min_angle(self): contours = self.create_contour() ndigits = 3 geojsoncontour.contour_to_geojson(contour=contours, geojson_filepath=self.geojson_file, min_angle_deg=None, ndigits=ndigits, unit=self.config.unit, stroke_width=5) self.assertTrue(os.path.exists(self.geojson_file)) os.remove(self.geojson_file)
def create_contour_json(self, filepath): logger.info('START: create contour json tiles') zoomfactor = 2.0 self.Z = scipy.ndimage.zoom(self.Z, zoom=zoomfactor, order=1) self.lonrange = scipy.ndimage.zoom(self.lonrange, zoom=zoomfactor, order=1) self.latrange = scipy.ndimage.zoom(self.latrange, zoom=zoomfactor, order=1) figure = Figure(frameon=False) FigureCanvas(figure) ax = figure.add_subplot(111) contours = ax.contour( self.lonrange, self.latrange, self.Z, levels=self.config.levels, cmap=self.config.colormap, norm=self.config.norm ) figure.clear() ndigits = 4 logger.info('converting contour to geojson') geojsoncontour.contour_to_geojson( contour=contours, geojson_filepath=filepath + '.geojson', contour_levels=self.config.levels, min_angle_deg=self.config.min_angle_between_segments, ndigits=ndigits, unit=self.config.unit, stroke_width=1 ) world_bounding_box_filepath = 'data/world_bounding_box.geojson' assert os.path.exists(world_bounding_box_filepath) togeojsontiles.geojson_to_mbtiles( filepaths=[filepath + '.geojson', world_bounding_box_filepath], tippecanoe_dir=TIPPECANOE_DIR, mbtiles_file='out.mbtiles', minzoom=0, maxzoom=5, full_detail=10, lower_detail=9, min_detail=7 ) logger.info('converting mbtiles to geojson-tiles') togeojsontiles.mbtiles_to_geojsontiles( tippecanoe_dir=TIPPECANOE_DIR, tile_dir=os.path.join(filepath, 'tiles/'), mbtiles_file='out.mbtiles', ) logger.info('DONE: create contour json tiles')
def test_matplotlib_contour_to_geojson(self): contours = self.create_contour() ndigits = 3 geojsoncontour.contour_to_geojson( contour=contours, geojson_filepath=self.geojson_file, min_angle_deg=self.config.min_angle_between_segments, ndigits=ndigits, unit=self.config.unit, stroke_width=5 ) self.assertTrue(os.path.exists(self.geojson_file)) self.assertTrue(filecmp.cmp(self.benchmark_geojson_file, self.geojson_file)) os.remove(self.geojson_file)
def test_matplotlib_contour_to_geojson(self): contours = self.create_contour() ndigits = 3 geojsoncontour.contour_to_geojson( contour=contours, geojson_filepath=self.geojson_file, min_angle_deg=self.config.min_angle_between_segments, ndigits=ndigits, unit=self.config.unit, stroke_width=5) self.assertTrue(os.path.exists(self.geojson_file)) self.assertTrue( filecmp.cmp(self.benchmark_geojson_file, self.geojson_file)) os.remove(self.geojson_file)
def create_geojson(self, filepath, stroke_width=1, levels=[], norm=None, overwrite=False): if not overwrite and os.path.exists(filepath): logger.error('Output file ' + filepath + ' already exists. Will not override.') return figure = Figure(frameon=False) FigureCanvas(figure) ax = figure.add_subplot(111) # contours = plt.contourf(lonrange, latrange, Z, levels=levels, cmap=plt.cm.plasma) contours = ax.contour(self.lonrange, self.latrange, self.Z, levels=levels, norm=norm, cmap=plt.cm.jet, linewidths=3) ndigits = len(str(int(1.0 / self.config.stepsize_deg))) + 1 logger.info('converting contour to geojson file: ' + filepath) geojsoncontour.contour_to_geojson( contour=contours, geojson_filepath=filepath, contour_levels=levels, min_angle_deg=self.config.min_angle_between_segments, ndigits=ndigits, unit='min', stroke_width=stroke_width) cbar = figure.colorbar(contours, format='%d', orientation='horizontal') cbar.set_label('Travel time [minutes]') # cbar.set_ticks(self.config.colorbar_ticks) ax.set_visible(False) figure.savefig( filepath.replace('.geojson', '') + "_colorbar.png", dpi=90, bbox_inches='tight', pad_inches=0, transparent=True, )
def test_return_string_if_destination_file_not_provided(self): contours = self.create_contour() ndigits = 3 result = geojsoncontour.contour_to_geojson( contour=contours, min_angle_deg=self.config.min_angle_between_segments, ndigits=ndigits, unit=self.config.unit, stroke_width=5) self.assertTrue(isinstance(result, str))
def test_contour_to_geojson_extra_properties(self): contour = self.create_contour() ndigits = 3 geojson_properties = { 'description': 'A description', 'stroke-opacity': 1.0 } geojsoncontour.contour_to_geojson( contour=contour, geojson_filepath=self.geojson_properties_file, min_angle_deg=self.config.min_angle_between_segments, ndigits=ndigits, unit=self.config.unit, stroke_width=5, geojson_properties=geojson_properties ) self.assertTrue(os.path.exists(self.geojson_properties_file)) self.assertTrue(filecmp.cmp(self.benchmark_geojson_properties_file, self.geojson_properties_file)) os.remove(self.geojson_properties_file)
def test_contour_to_geojson_extra_properties(self): contour = self.create_contour() ndigits = 3 geojson_properties = { 'description': 'A description', 'stroke-opacity': 1.0 } geojsoncontour.contour_to_geojson( contour=contour, geojson_filepath=self.geojson_properties_file, min_angle_deg=self.config.min_angle_between_segments, ndigits=ndigits, unit=self.config.unit, stroke_width=5, geojson_properties=geojson_properties) self.assertTrue(os.path.exists(self.geojson_properties_file)) self.assertTrue( filecmp.cmp(self.benchmark_geojson_properties_file, self.geojson_properties_file)) os.remove(self.geojson_properties_file)
def test_return_string_if_destination_file_not_provided(self): contours = self.create_contour() ndigits = 3 result = geojsoncontour.contour_to_geojson( contour=contours, min_angle_deg=self.config.min_angle_between_segments, ndigits=ndigits, unit=self.config.unit, stroke_width=5 ) self.assertTrue(isinstance(result, str))
def weimer(request): tmstpd = request.GET.get('tmstp') mod = request.GET.get('mod') data_to_query = tmstpd # url = 'https://geomagnet.ru/weimer_api/?type=epot&tmstp=2015-03-17-23:15' url = 'https://geomagnet.ru/weimer_api/?type=epot&tmstp=' + data_to_query logo = urllib.request.urlopen(url).read() fff = logo if (str(json.loads(fff))[2] == 'e'): url = 'https://geomagnet.ru/weimer_api/?type=epot&tmstp=2021-02-01-05:21' logo = urllib.request.urlopen(url).read() fff = logo arr = [] for line in fff.decode().splitlines(): s = line.strip() arr.append(s) j = json.loads(''.join(arr)) arr1 = [] data = j['coordinates'] for k in range(1, len(data)): arr_ = [] if (str(data[k][2]) != '0' and str(data[k][2]) != '1' and str(data[k][2]) != '2'): arr_.append(int(data[k][2])) arr_.append(float(data[k][1])) arr_.append(float(data[k][0])) arr1.append(arr_) arr1 = np.array(arr1) d = arr1 import matplotlib.tri as tri z = d[:, 0] x = d[:, 2] y = d[:, 1] xi = np.sort(np.unique(x)) yi = np.sort(np.unique(y)) from scipy.ndimage.filters import gaussian_filter triang = tri.Triangulation(x, y) interpolator = tri.LinearTriInterpolator(triang, z) Xi, Yi = np.meshgrid(xi, yi) zi = interpolator(Xi, Yi) zi = gaussian_filter(zi, sigma=.7) levels = 20 # len(np.unique(z)) contour = plt.contour(xi, yi, zi, levels=levels, cmap=plt.cm.jet, extend='both') # geojson = geojsoncontour.contour_to_geojson(contour=contour, stroke_width=10) return HttpResponse(geojson)
def test_return_python_object_if_serialize_argument_false(self): contours = self.create_contour() ndigits = 3 result = geojsoncontour.contour_to_geojson( serialize=False, geojson_filepath=self.geojson_file, strdump=True, contour=contours, min_angle_deg=self.config.min_angle_between_segments, ndigits=ndigits, unit=self.config.unit, stroke_width=5) self.assertTrue(isinstance(result, dict)) self.assertEqual(result["type"], "FeatureCollection")
def plot_kde(map, data, limits, name, cmap): lat_min, lat_max, lon_min, lon_max = limits ##### GET KDES bandwidth = 5e-4 kde = KernelDensity(kernel='gaussian', bandwidth=bandwidth, metric='haversine', atol=0.1) kde.fit(np.pi / 180.0 * data[['lat', 'lon']]) x = np.linspace(lon_min, lon_max, 500) y = np.linspace(lat_min, lat_max, 200) lon, lat = np.meshgrid(x, y) score = np.exp( kde.score_samples( np.pi / 180.0 * np.array([lat.reshape(-1), lon.reshape(-1)]).T)) score = score.reshape(lon.shape) / 25e6 ##### SET CMAP WITH ALPHA mycmap = cmap(np.arange(cmap.N)) mycmap[:, -1] = np.linspace(0, 0.9, cmap.N) mycmap = ListedColormap(mycmap) ##### CREATE CONTOUR THROUGH MPL contour = plt.contour(lon, lat, score, 30, cmap=mycmap) ##### CONVERT CONTOUR TO GEOJSON OBJECT geojson = geojsoncontour.contour_to_geojson( contour=contour, min_angle_deg=1.0, ndigits=10, stroke_width=2, #fill_opacity=0.8 ) ##### ADD GEOJSON OBJECT TO PLOT folium.GeoJson( geojson, style_function=lambda x: { 'color': x['properties']['stroke'], 'weight': x['properties']['stroke-width'], #'fillColor': None,#x['properties']['fill'], 'opacity': 1.0, #'fillOpacity': 0.0, }).add_to(folium.FeatureGroup(name=name).add_to(map))
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 ) 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 ) self.assertTrue(os.path.exists(self.geojson_file)) self.assertTrue(filecmp.cmp(self.benchmark_geojson_file, self.geojson_file)) os.remove(self.geojson_file)
def test_return_python_object_if_serialize_argument_false(self): contours = self.create_contour() ndigits = 3 result = geojsoncontour.contour_to_geojson( serialize=False, geojson_filepath=self.geojson_file, strdump=True, contour=contours, min_angle_deg=self.config.min_angle_between_segments, ndigits=ndigits, unit=self.config.unit, stroke_width=5 ) self.assertTrue(isinstance(result, dict)) self.assertEqual(result["type"], "FeatureCollection")
def store_bathy_contours( contour_file='contours.geojson', levels=[0, 100, 500, 1000, 2000, 3000], ): """ Store bathymetric contours as a geojson The geojson may be used for folium plots """ # Create contour data lon_range, lat_range, Z depth = -xr.open_dataset(_bathy_file)['elevation'] contours = depth.plot.contour(levels=levels, cmap='gray_r') # Convert matplotlib contour to geojson from geojsoncontour import contour_to_geojson contours_geojson = contour_to_geojson( contour=contours, geojson_filepath=os.path.join(bathy_dir, contour_file), ndigits=3, unit='m', )
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
# numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None) # Return evenly spaced numbers over a specified interval. # num = number of samples to generate contourIntervals = { # "1": numpy.linspace(start = 0, stop = 150, num = n_contours["1"]), # "2": numpy.linspace(start = 0, stop = 150, num = n_contours["2"]), # "3": numpy.linspace(start = 0, stop = 150, num = n_contours["3"]), # "5": numpy.linspace(start = 0, stop = 150, num = n_contours["5"]), "10": numpy.linspace(start = 0, stop = 150, num = n_contours["10"]) } # plot contour for interval in contourIntervals: contour_grey = ax.contour(lonRange, latRange, pm25Value,\ levels = contourIntervals[interval],\ cmap = None,\ colors = "black"\ ) ### Convert matplotlib contour to geojson geojsoncontour.contour_to_geojson( contour = contour_grey, geojson_filepath = DIR + 'data/pm25Contour_grey_' + interval + '.geojson', min_angle_deg = 10.0, ndigits = 3, stroke_width = 2, unit = "μg/m^3" ) end = time.time() logger.info("pm2.5 contour geojson completes: %f" % (end - start))
import geojsoncontour as gjc import matplotlib.cm as cm #plt.clf() monitorData = [] lat = [] lon = [] level = [] with open( "180502-HexbinNoise.txt") as tsvFile: next(tsvFile) next(tsvFile)#skip header fileReader = csv.DictReader(tsvFile, delimiter='\t') for row in fileReader: monitorData.append(dict(row)) for monitor in monitorData: lat.append(float(monitor['Latitude'])) lon.append(float(monitor['Longitude'])) level.append(float(monitor['DNL 24 hr'])) ax = plt.figure(figsize=(12,8)).add_subplot(111) contour = ax.tricontour(lon, lat, level, 200, linewidths=2, extend='neither', cmap=cm.nipy_spectral) plt.colorbar(contour, shrink=1.2, extend='neither', extendrect='true', orientation='vertical', drawedges='false') # Default contour converison settings gjc.contour_to_geojson( contour=contour, geojson_filepath='noiseMap.geojson', min_angle_deg=10.0, ndigits=4, unit='m' )
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 = 10 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) contour = ax.contour(lonrange, latrange, Z, levels=levels, cmap=plt.cm.jet) # Convert matplotlib contour to geojson geojsoncontour.contour_to_geojson( contour=contour, geojson_filepath='out.geojson', contour_levels=levels, min_angle_deg=10.0, ndigits=3, unit='m' )
def contour(lon, lat, data, time_str, timerange_str, **kwargs): """Contour 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 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 Contour levels to plot. linewidths: list, array Linewidths corresponding to each contour level colors : color string (hexademicals) Colors corresponding to each contour 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') if levels is not None and colors is not None: c = ax.contour(lon, lat, data, levels, colors=colors) else: c = ax.contour(lon, lat, data) geojson = json.loads( geojsoncontour.contour_to_geojson(contour=c, ndigits=2)) out = [] out.append('Title: %s %s\n' % (plotinfo, time_str)) out.append('RefreshSeconds: 60\n') out.append('TimeRange: %s\n' % (timerange_str)) for feature in geojson['features']: coords = feature['geometry']['coordinates'] level = '%s' % (feature['properties']['level-value']) idx = feature['properties']['level-index'] if int(levels[idx]) == int(float(level)): try: lws = list(kwargs['linewidths']) linewidth = lws[idx] except: linewidth = kwargs['linewidths'] else: linewidth = 1 rgb = hex2rgb(feature['properties']['stroke']) out.append('Color: %s 255\n' % (' '.join(rgb))) out.append('Line: %s, 0, "%s"\n' % (linewidth, level)) for coord in coords: out.append(' %s, %s\n' % (coord[1], coord[0])) out.append('End:\n\n') plt.close(fig) return out
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 = 10 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) contour = ax.contour(lonrange, latrange, Z, levels=levels, cmap=plt.cm.jet) # Convert matplotlib contour to geojson geojsoncontour.contour_to_geojson(contour=contour, geojson_filepath='out.geojson', contour_levels=levels, min_angle_deg=10.0, ndigits=3, unit='m')
def test(request): tmstpd = request.GET.get('tmstp') mod = request.GET.get('mod') data_to_query = tmstpd just_date = tmstpd[0:10] date1 = time.strptime(just_date, "%Y-%m-%d") date2 = time.strptime('2020-10-30', "%Y-%m-%d") if (mod == 'w'): # # url = 'https://geomagnet.ru/weimer_api/?type=epot&tmstp='+data_to_query url = 'https://geomagnet.ru/weimer_api/?type=epot&tmstp=2021-01-24-20:02' logo = urllib.request.urlopen(url).read() fff = logo arr = [] for line in fff.decode().splitlines(): s = line.strip() arr.append(s) j = json.loads(''.join(arr)) arr1 = [] data = j['coordinates'] for k in range(1, len(data)): arr_ = [] arr_.append(int(data[k][2])) arr_.append(float(data[k][1])) arr_.append(float(data[k][0])) arr1.append(arr_) arr1 = np.array(arr1) d = arr1 import matplotlib.tri as tri z = d[:, 0] x = d[:, 2] y = d[:, 1] xi = np.sort(np.unique(x)) yi = np.sort(np.unique(y)) from scipy.ndimage.filters import gaussian_filter triang = tri.Triangulation(x, y) interpolator = tri.LinearTriInterpolator(triang, z) Xi, Yi = np.meshgrid(xi, yi) zi = interpolator(Xi, Yi) zi = gaussian_filter(zi, sigma=.7) levels = len(np.unique(z)) contour = plt.contour(xi, yi, zi, levels=levels, cmap=plt.cm.jet, extend='both') # geojson = geojsoncontour.contour_to_geojson(contour=contour, stroke_width=10) return HttpResponse(geojson) ### # else: longi = [i * 0.3515625 - 180 for i in range(1025)] lati = [j * 0.3515625 - 90 for j in range(513)] ctr = 0 ct = 0 # data_to_query = tmstpd # just_date = tmstpd[0:10] # date1 = time.strptime(just_date, "%Y-%m-%d") # date2 = time.strptime('2020-10-30', "%Y-%m-%d") typ = 'new' if (date1 >= date2): typ = 'new' else: typ = 'old' if typ == 'new': # return redirect('/getdata?type=aurora&dt='+data_to_query) # url = '/getdata?type=aurora&dt='+data_to_query # logo = urllib.request.urlopen(url).read(); # fff = logo; # arr = []; # for line in fff.decode().splitlines(): # s=line.strip() # arr.append(s) # j = json.loads(''.join(arr)); j = getdata('aurora', data_to_query) if j is None: return JsonResponse(None, safe=False) arr1 = [] data = j['coordinates'] for k in range(1, len(data)): arr_ = [] if (str(data[k][2]) != '0' and str(data[k][2]) != '1' and str(data[k][2]) != '2'): arr_.append(int(data[k][2])) arr_.append(float(data[k][1])) arr_.append(float(data[k][0])) arr1.append(arr_) arr1 = np.array(arr1) d = arr1 import matplotlib.tri as tri z = d[:, 0] x = d[:, 2] y = d[:, 1] xi = np.sort(np.unique(x)) yi = np.sort(np.unique(y)) from scipy.ndimage.filters import gaussian_filter triang = tri.Triangulation(x, y) interpolator = tri.LinearTriInterpolator(triang, z) Xi, Yi = np.meshgrid(xi, yi) zi = interpolator(Xi, Yi) zi = gaussian_filter(zi, sigma=.7) levels = len(np.unique(z)) contour = plt.contour(xi, yi, zi, levels=levels, cmap=plt.cm.jet, extend='both') # geojson = geojsoncontour.contour_to_geojson(contour=contour, stroke_width=10) return HttpResponse(geojson) if typ == 'old': logo = getdata('aurora', data_to_query) # url = '/getdata?type=aurora&dt='+data_to_query # logo = urllib.request.urlopen(url).read(); fff = logo arr = [] for line in fff.splitlines(): if (ctr == 1025): ctr = 0 ct += 1 if '#' in line.decode(): continue s = line.split() for k in range(1, len(s), 3): ciqw = 0 if ((s[k - 1]) == '0' or (s[k - 1]) == '1' or (s[k - 1]) == '2'): continue arr_ = [] arr_.append(float(s[k - 1])) arr_.append((lati[ct])) arr_.append((longi[k - 1])) arr.append(arr_) ct += 1 arr = np.array(arr) contour_data = pd.DataFrame({ 'category': arr[..., 0], 'latitude': arr[..., 1], 'longitude': arr[..., 2] }) Z = contour_data.pivot_table(index='longitude', columns='latitude', values='category').T.values X_unique = np.sort(contour_data['longitude'].unique()) Y_unique = np.sort(contour_data['latitude'].unique()) X, Y = np.meshgrid(X_unique, Y_unique) n_contours = 50 # contour_data['category'].nunique()#40 levels = np.linspace(start=0, stop=100, num=n_contours) contour = plt.contour(X, Y, Z, levels=levels, cmap=plt.cm.jet) geojson = geojsoncontour.contour_to_geojson( contour=contour, min_angle_deg=1.0, ndigits=1, stroke_width=2, ) return HttpResponse(geojson)