del twinA_MichiganID[i] del twinB_SVID[i] del twinB_MichiganID[i] del twinzygos[i] for i in range(0,len(twinA_SVID)): print("At individual:",i+1) twinA = find(Michigan_ID, twinA_MichiganID[i]) twinB = find(Michigan_ID, twinB_MichiganID[i]) mapit = folium.Map(location=[IDlatlon[twinA[0]][1], IDlatlon[twinA[0]][2]], zoom_start=4) # create base map #(__mapit, __IDlatlon, __person, __subsetIndex, __twinIndex) mapitTwinA = baseLayer(mapit, IDlatlon, twinA, 1, 1, twinA_SVID[i]) #navy + white # plot twin A as twin reference with white square and number mapitTwinB = colorLayer(mapitTwinA, IDlatlon, twinB, 1, 2, twinB_SVID[i])#fuschia + default color # plot twin B with interactive layer and color folium.LayerControl().add_to(mapitTwinB) fileName = '{zygos}_{twinA}_{twinB}.html'.format(zygos = twinzygos[i], twinA = twinA_SVID[i], twinB=twinB_SVID[i]) os.chdir('/Users/Shiloh/Box/Shiloh_Geography_Spring2019/foliumMap')# new directory mapitTwinB.save(fileName) # for i in range(0,len(noPair)): # print('At individual:', i+1) # twin = find(Michigan_ID, noPair[i][0]) # mapit = folium.Map(location = [IDlatlon[twin[0]][1], IDlatlon[twin[0]][2]], zoom_start =4 ) # mapitTwinA = colorLayer(mapit, IDlatlon, twin, 1, 2, noPair[i][1]) # folium.LayerControl().add_to(mapit) # fileName = '{twinSV}.html'.format(twinSV = noPair[i][1]) # os.chdir('/Users/Shiloh/Box/Shiloh_Geography_Spring2019/foliumMap') # mapit.save(fileName)
return 'orange' # getting coordinates (lst, height) = get_coordinates(data) map = fl.Map(location=[40,-100]) #creating a map object fgv = fl.FeatureGroup(name='Volcanoes') # lst = [[13.357,74.79], [13.356,74.79], [13.358,74.79], [13.357,74.80]] for coordinate, ele in zip(lst, height): fgv.add_child(fl.CircleMarker(location=coordinate, radius=6, popup="Elevation = {}".format(ele), fill_color=height_intensity(ele), color='grey', fill_opacity=0.6)) #adding popurlation polygon using geoJSON fgp = fl.FeatureGroup(name='Popurlation') fh = '''D:/Code/Python/Courses/The Python Mega Course Build 10 Real World Applications/11 Application 2 Creating Webmaps with Python and Folium/world.json''' dat = open(fh, encoding="utf-8-sig").read() fgp.add_child(fl.GeoJson(data=dat, style_function = lambda x: { 'fillColor' : 'green' if x['properties']['POP2005'] < 10000000 # lesser than 10,000,000 else 'red' if x['properties']['POP2005'] > 20000000 # greater than 20,000,000 else 'orange' })) # adding to map map.add_child(fgv) map.add_child(fgp) map.add_child(fl.LayerControl()) map.save('./index.html') #creating and saving maps in html
def show_result_map(result=None, items_list=[], target_area=None, overview=False): center = [38, 35] zoom = 6 if not items_list: items = result.items() m = folium.Map(location=center, zoom_start=zoom) if target_area is not None: geo = target_area.__geo_interface__ m.add_child( folium.GeoJson(geo, name='Area of Study', style_function=lambda x: { 'color': 'red', 'alpha': 0 })) for item in items: if overview: #get overview band #get overview band band_url = item.assets['thumbnail']['href'] pol = Polygon(item.geometry['coordinates'][0]) folium.raster_layers.ImageOverlay( image=band_url, name=item.properties['sentinel:product_id'], bounds=[[ min(pol.exterior.coords.xy[1]), min(pol.exterior.coords.xy[0]) ], [ max(pol.exterior.coords.xy[1]), max(pol.exterior.coords.xy[0]) ]], #bounds=[item.geometry['coordinates'][0][0], item.geometry['coordinates'][0][3]], opacity=1, interactive=True, cross_origin=True, zindex=1, #alt="Wikipedia File:Mercator projection SW.jpg", ).add_to(m) else: # Create a string for the name containing the path and row of this Polygon name = item.properties['sentinel:product_id'] # Create the folium geometry of this Polygon g = folium.GeoJson(item.geometry, name=name) # Add a folium Popup object with the name string g.add_child(folium.Popup(name)) # Add the object to the map g.add_to(m) folium.LayerControl().add_to(m) return m else: m = folium.Map(location=center, zoom_start=zoom) if target_area is not None: geo = target_area.__geo_interface__ m.add_child( folium.GeoJson(geo, name='Area of Study', style_function=lambda x: { 'color': 'red', 'alpha': 0 })) for item in items_list: if overview: #get overview band band_url = item.assets['thumbnail']['href'] pol = Polygon(item.geometry['coordinates'][0]) folium.raster_layers.ImageOverlay( image=band_url, name=item.properties['sentinel:product_id'], bounds=[[ min(pol.exterior.coords.xy[1]), min(pol.exterior.coords.xy[0]) ], [ max(pol.exterior.coords.xy[1]), max(pol.exterior.coords.xy[0]) ]], #bounds=[item.geometry['coordinates'][0][0], item.geometry['coordinates'][0][3]], opacity=1, interactive=True, cross_origin=True, zindex=1, #alt="Wikipedia File:Mercator projection SW.jpg", ).add_to(m) else: # Create a string for the name containing the path and row of this Polygon name = item.properties['sentinel:product_id'] # Create the folium geometry of this Polygon g = folium.GeoJson(item.geometry, name=name) # Add a folium Popup object with the name string g.add_child(folium.Popup(name)) # Add the object to the map g.add_to(m) folium.LayerControl().add_to(m) return m
def __init__(self, **kwargs): import logging logging.getLogger("googleapiclient.discovery_cache").setLevel( logging.ERROR) if "ee_initialize" not in kwargs.keys(): kwargs["ee_initialize"] = True if kwargs["ee_initialize"]: ee_initialize() # Default map center location and zoom level latlon = [40, -100] zoom = 4 # Interchangeable parameters between ipyleaflet and folium if "center" in kwargs.keys(): kwargs["location"] = kwargs["center"] kwargs.pop("center") if "location" in kwargs.keys(): latlon = kwargs["location"] else: kwargs["location"] = latlon if "zoom" in kwargs.keys(): kwargs["zoom_start"] = kwargs["zoom"] kwargs.pop("zoom") if "zoom_start" in kwargs.keys(): zoom = kwargs["zoom_start"] else: kwargs["zoom_start"] = zoom if "add_google_map" not in kwargs.keys( ) and "basemap" not in kwargs.keys(): kwargs["add_google_map"] = True if "plugin_LatLngPopup" not in kwargs.keys(): kwargs["plugin_LatLngPopup"] = True if "plugin_Fullscreen" not in kwargs.keys(): kwargs["plugin_Fullscreen"] = True if "plugin_Draw" not in kwargs.keys(): kwargs["plugin_Draw"] = False if "Draw_export" not in kwargs.keys(): kwargs["Draw_export"] = True if "plugin_MiniMap" not in kwargs.keys(): kwargs["plugin_MiniMap"] = False if "plugin_LayerControl" not in kwargs.keys(): kwargs["plugin_LayerControl"] = False super().__init__(**kwargs) self.baseclass = "folium" if kwargs.get("add_google_map"): ee_basemaps["ROADMAP"].add_to(self) if kwargs.get("basemap"): ee_basemaps[kwargs.get("basemap")].add_to(self) if kwargs.get("plugin_LatLngPopup"): folium.LatLngPopup().add_to(self) if kwargs.get("plugin_Fullscreen"): plugins.Fullscreen().add_to(self) if kwargs.get("plugin_Draw"): plugins.Draw(export=kwargs.get("Draw_export")).add_to(self) if kwargs.get("plugin_MiniMap"): plugins.MiniMap().add_to(self) if kwargs.get("plugin_LayerControl"): folium.LayerControl().add_to(self) self.fit_bounds([latlon, latlon], max_zoom=zoom)
popup=folium.Popup(max_width=500).add_child( folium.Vega(vis2, width=500, height=250)) ).add_to(dat_grphs) folium.Marker( location=[6.942936, 80.610974], icon=folium.Icon(color='blue', icon='bar-chart', prefix='fa'), popup=folium.Popup(max_width=500).add_child( folium.Vega(vis3, width=500, height=250)) ).add_to(dat_grphs) plugins.HeatMap(datalist).add_to(sensor_hMap) # add layer control: folium.LayerControl(collapsed=True).add_to(tea_map) # enable lat/lon popovers for convenience tea_map.add_child(folium.LatLngPopup()) # vector drawing plugins.Draw( export=False, filename='my_data.geojson', position='topleft', draw_options={'polyline': {'allowIntersection': False}}, edit_options={'poly': {'allowIntersection': False}} ).add_to(tea_map) # m.save(os.path.join('results', 'Plugins_1.html'))
Track colored by heart rate =========================== This example will create a map and color the track according to the measured heart rate. """ import folium from gpxplotter import ( read_gpx_file, create_folium_map, add_segment_to_map, add_all_tiles, ) the_map = create_folium_map(tiles='kartverket_topo4') # Add pre-defined tiles: add_all_tiles(the_map) for track in read_gpx_file('example1.gpx'): for i, segment in enumerate(track['segments']): add_segment_to_map(the_map, segment, color_by='hr') # Add layer control to change tiles: folium.LayerControl(sortLayers=True).add_to(the_map) # To store the map as a HTML page: # the_map.save('map_001.html') # To display the map in a Jupyter notebook: the_map
map_cctv = folium.Map(location=[35.22323, 128.60946], zoom_start=11, tiles='OpenStreetMap') rfile = open("changwon.json", 'r', encoding='cp949').read() jsonData = json.loads(rfile) folium.GeoJson(jsonData, name='읍면동 구분').add_to(map_cctv) # 4-3-5. 마우스 포지션(위도, 경도) 찾기 기능 # from folium.plugins import MousePosition # MousePosition().add_to(map_cctv) # 4-3-6. 측정도구 기능 # from folium.plugins import MeasureControl # map_pplace.add_child(MeasureControl()) len(data[data['카메라대수'] == 4]) fg = folium.FeatureGroup(name="cctv 전체") # 전체그룹 설정 g1 = plugins.FeatureGroupSubGroup(fg, '교통용 cctv') # 서브그룹 틀 만들기 g2 = plugins.FeatureGroupSubGroup(fg, '비교통용 cctv') map_cctv.add_child(fg) # 서브 그룹 맵에 넣기 map_cctv.add_child(g1) map_cctv.add_child(g2) for i in range(0, len(data_traffic)): folium.Circle([data_traffic["위도"][i], data_traffic["경도"][i]], radius=50, color="#ffc039", fill=True).add_to(g1) for j in range(0, len(data_non_traffic)): folium.Circle([data_non_traffic["위도"][j], data_non_traffic["경도"][j]], radius=50, color="#376091", fill=True).add_to(g2) folium.LayerControl(collapsed=False).add_to(map_cctv) map_cctv.save("map_cctv.html")
for lati,lng in zip(Biblioteca.Lat,Biblioteca.Long): coordenadas.append([lati,lng]) Mapa = folium.Map(location=[33.0,65.0],zoom_start=5) Mapa.add_child(plugins.HeatMap(coordenadas)) folium.Marker([33.0,65.0],popup='Afeganistão',tooltip='Click aqui', icon=folium.Icon(color='green')).add_to(Mapa) Mapa.add_child(folium.LatLngPopup()) draw = plugins.Draw(export=True,) draw.add_to(Mapa) folium.raster_layers.TileLayer('Open Street Map').add_to(Mapa) folium.raster_layers.TileLayer('Stamen Terrain').add_to(Mapa) folium.raster_layers.TileLayer('Stamen Toner').add_to(Mapa) folium.raster_layers.TileLayer('Stamen watercolor').add_to(Mapa) folium.raster_layers.TileLayer('CartoDB Positron').add_to(Mapa) folium.raster_layers.TileLayer('CartoDB Dark_Matter').add_to(Mapa) folium.LayerControl().add_to(Mapa) minimap=plugins.MiniMap(toggle_display = True) Mapa.add_child(minimap) plugins.ScrollZoomToggler().add_to(Mapa) plugins.Fullscreen(position = 'topright').add_to(Mapa) Mapa.save("Casos no mundo.html")
return "blue" else: return "red" harita=folium.Map(location=[38.9597594, 34.9249653],zoom_start=7,tiles="Mapbox Control Room") nufusHaritasi=folium.FeatureGroup(name="Nufus Haritasi") for il,en,boy,nuf in zip(sehir,enlem,boylam,nufus): renk=Renklendir(int(nuf.replace(".",""))) nufusHaritasi.add_child(folium.Marker(location=[en,boy],tooltip=(il+" nüfus:"+nuf),icon=folium.Icon(color=renk))) sehirIndex=pdSehirNufuslar.set_index("sehir") def NufusKontrol(shr): sonuc=int(sehirIndex.loc[shr, 'nufus'].replace(".","")) return Renklendir(sonuc) ilSinirlari=folium.FeatureGroup(name="İl sınırları") ilSinirlari.add_child(folium.GeoJson(open("turkey-il-sinirlar.json","r",encoding="utf-8-sig").read(), style_function=lambda il: {'fillColor':NufusKontrol(il["properties"]["Name"])})) harita.add_child(nufusHaritasi) harita.add_child(ilSinirlari) harita.add_child(folium.LayerControl()) harita.save("turkey.html")
def create_markup_map(name: str, df: pd.core.frame.DataFrame): """Place a markup for each point with a valid housing price evaluation and position """ map_ = folium.Map( location=france_location, zoom_start=3, control_scale=True, tiles="openstreetmap", ) mcg = folium.plugins.MarkerCluster(control=False) map_.add_child(mcg) houses = folium.plugins.FeatureGroupSubGroup(mcg, "houses") appartements = folium.plugins.FeatureGroupSubGroup(mcg, "appartements") others = folium.plugins.FeatureGroupSubGroup(mcg, "others") map_.add_child(houses) map_.add_child(appartements) map_.add_child(others) for _, row in df.iterrows(): housing_type = row["Type local"] if housing_type == "Maison": color = "darkgreen" icon = "home" context = houses elif housing_type == "Appartement": color = "red" icon = "pause" context = appartements else: color = "black" icon = "info-sign" context = others price = int(row["Valeur fonciere"]) address = get_address_from_row(row) context.add_child( folium.Marker( (row["lat"], row["lon"]), popup=folium.Popup( f"{housing_type}</br> {address} <b>{price}€</b>", # Not working properly max_width="400px", min_width="200px", ), tooltip=housing_type, icon=folium.Icon(color=color, icon=icon), ) ) map_.add_child( plugins.Fullscreen( position="topright", title="Expand me", title_cancel="Exit me", force_separate_button=True, ) ) map_.add_child(folium.LayerControl(collapsed=False)) map_.add_child(plugins.MeasureControl()) map_.add_child(plugins.MiniMap()) save_map(map_, name)
'weight': 0.3, 'fillOpacity': 0.5 if x['id'] in person['States'] else 0.0 } def states_traveled(person, color): """ Take a person's name and a color to create GeoJson overlay for states that the person has traveled to. Color will be used in style function for fill. Adds overlay to map. """ folium.GeoJson(data=state_geo, name=person['Name'] + ' - ' + str(len(person['States'])), style_function=state_style(person, color)).add_to(us_map) ''' EXAMPLE CODE: person_1 = { 'Name' : 'Person 1', 'States' : ['ME', 'FL', 'CA', 'WA', 'OR'] } states_traveled(person_1, 'red') ''' folium.LayerControl(hideSingleBase=True).add_to(us_map) us_map.save('us_map.html')
if elev in range(minimum, minimum + step_value): color = 'green' elif elev in range(minimum, minimum + step_value * 2): color = 'orange' else: color = 'red' return color # Add the feature group created above to be able to filter out the icons in the Layer Control feature_group = folium.FeatureGroup(name='Volcano Locations') # Add markers one by one using the data range defined in your dataset for lat, lon, name, elevation in zip(data['LAT'], data['LON'], data['NAME'], data['ELEV']): feature_group.add_child(folium.Marker(location=[lat, lon], popup=name, icon=folium.Icon(marker_color(elevation), icon_color='black'))).add_to(my_map) geojson_layer = my_map.add_child( folium.GeoJson(json.load(open('data_files/world_population.json')), name='World Population', style_function=lambda x: {'fillColor': 'green' if x['properties']['POP2005'] <= 10000000 else 'orange' if 10000000 < x['properties']['POP2005'] <= 20000000 else 'red'})) layer_controller = my_map.add_child(folium.LayerControl(position='topright', collapsed=True)) # Save the folium map to a directory as an html file my_map.save(outfile='output_files/west-coast_map.html') print('Creating a webmap for Volcanoes in the US...')
def mapping(date): df = readfile(date) # create empty map zoomed in on San Francisco m = folium.Map(location=(39, -98), zoom_start=4) folium.TileLayer('openstreetmap').add_to(m) cluster1 = folium.plugins.MarkerCluster(name="Not Relevant").add_to(m) cluster2 = folium.plugins.MarkerCluster(name="Relevant").add_to(m) # add a marker for every record in the filtered data, use a clustered view for i in df.index: if df.loc[i, 'relevant'] == 0: tweet = df.loc[i, 'text'] location = (df.loc[i, 'twlong'], df.loc[i, 'twlat']) state = df.loc[i, 'state'] county = df.loc[i, 'name'] url = df.loc[i, 'url'] folium.Marker( location=[df.loc[i, 'twlat'], df.loc[i, 'twlong']], popup= '<b>Tweet: </b>%s<br></br><b>Location: </b>%s<br></br><b>State: </b>%s<br></br><b>County: </b>%s<br></br><b>URL: </b><a href="%s" target="_blank">%s</a>' % (tweet, location, state, county, url, url), icon=folium.Icon(icon='fire', color='red')).add_to(cluster1) elif df.loc[i, 'relevant'] == 1: tweet = df.loc[i, 'text'] location = (df.loc[i, 'twlong'], df.loc[i, 'twlat']) state = df.loc[i, 'state'] county = df.loc[i, 'name'] url = df.loc[i, 'url'] folium.Marker( location=[df.loc[i, 'twlat'], df.loc[i, 'twlong']], popup= '<b>Tweet: </b>%s<br></br><b>Location: </b>%s<br></br><b>State: </b>%s<br></br><b>County: </b>%s<br></br><b>URL: </b><a href="%s" target="_blank">%s</a>' % (tweet, location, state, county, url, url), icon=folium.Icon(icon='fire', color='red')).add_to(cluster2) # add circle for searching #for j in df.index: # folium.CircleMarker(location = [df.loc[j,'Latitude'],df.loc[j,'Longitude']], # radius = 10, # color = '#FF0000', # fill = True, # fill_color = '#FF0000').add_to(m) statedf = pd.DataFrame() ind = df[['Latitude', 'Longitude']].drop_duplicates().index df.loc[ind, 'state'].value_counts() statedf['state'] = df.loc[ind, 'state'].value_counts().index statedf['value'] = df.loc[ind, 'state'].value_counts().values statedf wholestate = statename.merge(statedf, left_on='name', right_on='state', how='left').drop(['state', 'abbreviation'], axis=1).fillna(0) m.choropleth( geo_data=states, name='# of Fire detected', data=wholestate, columns=['name', 'value'], key_on='feature.properties.name', fill_color='YlOrRd', fill_opacity=0.7, line_opacotu=0.2, legend_name='Fire Count', ) folium.LayerControl().add_to(m) m.add_child(MeasureControl()) filepath = f'../{date}map.html' m.save(filepath)
def index(): if flask.request.args.get('date') == None: return flask.render_template('index.html', dates=dates, phenom=m_type, months=month) date = int(flask.request.args.get('date')) month_selected = flask.request.args.get('months') phenom_long = flask.request.args.get('phenom') duration = int(flask.request.args.get('duration')) for key, name in CATEGORIES.iteritems(): if name == phenom_long: phenom = key choosed_month, year = month_selected.split('/') try: start_date = datetime.datetime(int(year), int(choosed_month), date, 00, 00, 00) end_date = datetime.datetime(int(year), int(choosed_month), date, 23, 59, 59) + \ datetime.timedelta(days=duration) except: return flask.render_template('error.html', dates=dates, phenom=m_type, months=month, error='date') # http://stackoverflow.com/questions/12438990/select-records-from-postgres-where-timestamp-is-in-certain-rangsoure if phenom_long == 'temperature': sql_sensor = "SELECT DISTINCT idsensor FROM data where (timestamp > '%s' and timestamp < '%s') and (measuretype = 'CA' or measuretype = 'ST');" % ( start_date, end_date) elif phenom_long == 'humidity': sql_sensor = "SELECT DISTINCT idsensor FROM data where (timestamp > '%s' and timestamp < '%s') and (measuretype = 'CB' or measuretype = 'SH');" % ( start_date, end_date) else: sql_sensor = "SELECT DISTINCT idsensor FROM data where (timestamp > '%s' and timestamp < '%s') and measuretype = '%s';" % ( start_date, end_date, str(phenom)) holice_map = folium.Map(MAP_CENTER, zoom_start=18, tiles=None) folium.TileLayer('OpenStreetMap').add_to(holice_map) folium.TileLayer('MapQuestOpen').add_to(holice_map) # Map.add_children(folium.plugins.ImageOverlay(...)) # ICON_URL = 'static/python.jpg' holice_map.add_children( plugins.ImageOverlay( ICON_URL, [PICTURE_COORS], opacity=0.5, )) # folium.LayerControl().add_to(holice_map) holice_map.add_children(folium.LayerControl()) cur.execute(sql_sensor) # list of sensors [int,int,int], instead of [(int,), (int,), (int,)] sensors = [i[0] for i in cur.fetchall()] multi_iter1 = {} locations, popups = [], [] for sensor_sql in sensors: # print sensor_sql for sensor in SENSOR: # print sensor if sensor[0] == sensor_sql: sensor_start_date = datetime.datetime.strptime( sensor[2], "%Y-%m-%d") sensor_end_date = datetime.datetime.strptime( sensor[3], "%Y-%m-%d %H:%M:%S") start_date_new = start_date end_date_new = end_date # print str(end_date) + ' > ' + str(sensor_start_date) # sensor have to not end measurement before start date and not start measurement after the end of end day if end_date >= sensor_start_date and start_date <= sensor_end_date: # if sensor start measurement after start day, the start day will be replaced by sensor start day # if value of start_date and end_date will be replaced, end of sensor measurement after end_date will not be replaced if sensor_start_date > start_date: #print start_date, sensor_start_date start_date_new = sensor_start_date if sensor_end_date < end_date: #print end_date, sensor_end_date end_date_new = sensor_end_date # + datetime.timedelta(days=duration) sensor_data = {} if phenom_long == 'temperature': sql_data_sensor = "SELECT measurevalue, timestamp FROM data WHERE (timestamp > '%s' and timestamp < '%s') and (measuretype = 'CA' or measuretype = 'ST') and idsensor = %d;" % ( start_date_new, end_date_new, int(sensor[0])) elif phenom_long == 'humidity': sql_data_sensor = "SELECT measurevalue, timestamp FROM data WHERE (timestamp > '%s' and timestamp < '%s') and (measuretype = 'CB' or measuretype = 'SH') and idsensor = %d;" % ( start_date_new, end_date_new, int(sensor[0])) else: sql_data_sensor = "SELECT measurevalue, timestamp FROM data WHERE (timestamp > '%s' and timestamp < '%s') and measuretype = '%s' and idsensor = %d;" % ( start_date_new, end_date_new, str(phenom), int(sensor[0])) print sql_data_sensor cur.execute(sql_data_sensor) # sort tuples by time_pattern sql_data = sorted(list(cur.fetchall()), key=lambda time: time[1]) for row in sql_data: # http://stackoverflow.com/questions/16198606/python-linux-timestamp-to-date-time-and-reverse # https://docs.python.org/2/library/datetime.html#strftime-strptime-behavior time_index = int( time.mktime( time.strptime(str(row[1]), "%Y-%m-%d %H:%M:%S")) * 1000) # some data do not have measurevalue (83k rows) if row[0]: value = float(row[0]) else: value = 0.0 sensor_data[time_index] = value multi_iter1[sensor[0]] = sensor_data # if there are no data if multi_iter1[sensor[0]]: vis = vincent.Line(multi_iter1[sensor[0]], width=600, height=200) x_axis_str = 'data for sensor (' + str( sensor[0]) + '). Time period: ' + str( start_date_new) + ' to ' + str(end_date_new) vis.axis_titles(x=str(x_axis_str), y=phenom_long) vis._axis_properties(axis='y', title_size=15, title_offset=-10, label_align='right', label_angle=0, color='#000000') vis.scales['x'] = vincent.Scale(name='x', type='time', range='width', domain=vincent.DataRef( data='table', field="data.idx")) vis.scales['y'] = vincent.Scale(name='y', type='linear', range='height', domain=vincent.DataRef( data='table', field="data.val")) vis.to_json('static/vis_%s.json' % sensor[0]) popups.append( folium.Popup(max_width=1900).add_child( folium.Vega(json.load( open('static/vis_%s.json' % sensor[0])), width="100%", height="100%"))) locations.append(sensor[1]) if not locations: return flask.render_template('error.html', dates=dates, phenom=m_type, months=month, error='locations') holice_map.add_children(plugins.MarkerCluster(locations, popups)) holice_map.save('templates/map.html') return flask.render_template('map.html')
def map_trips(feed, trip_ids, color_palette=cs.COLORS_SET2, *, include_stops=True): """ Return a Folium map showing the given trips and (optionally) their stops. Parameters ---------- feed : Feed trip_ids : list IDs of trips in ``feed.trips`` color_palette : list Palette to use to color the routes. If more routes than colors, then colors will be recycled. include_stops : boolean If ``True``, then include stops in the map Returns ------- dictionary A Folium Map depicting the shapes of the trips. If ``include_stops``, then include the stops for each trip. Notes ------ - Requires Folium """ import folium as fl import folium.plugins as fp # Get routes slice and convert to dictionary trips = (feed.trips.loc[lambda x: x["trip_id"].isin(trip_ids)].fillna( "n/a").to_dict(orient="records")) # Create colors n = len(trips) colors = [color_palette[i % len(color_palette)] for i in range(n)] # Initialize map my_map = fl.Map(tiles="cartodbpositron") # Collect route bounding boxes to set map zoom later bboxes = [] # Create a feature group for each route and add it to the map for i, trip in enumerate(trips): collection = feed.trip_to_geojson(trip_id=trip["trip_id"], include_stops=include_stops) group = fl.FeatureGroup(name="Trip " + trip["trip_id"]) color = colors[i] for f in collection["features"]: prop = f["properties"] # Add stop if f["geometry"]["type"] == "Point": lon, lat = f["geometry"]["coordinates"] fl.CircleMarker( location=[lat, lon], radius=8, fill=True, color=color, weight=1, popup=fl.Popup(hp.make_html(prop)), ).add_to(group) # Add path else: # Path prop["color"] = color path = fl.GeoJson( f, name=trip, style_function=lambda x: {"color": x["properties"]["color"]}, ) path.add_child(fl.Popup(hp.make_html(prop))) path.add_to(group) # Direction arrows, assuming, as GTFS does, that # trip direction equals LineString direction fp.PolyLineTextPath( path, " \u27A4 ", repeat=True, offset=5.5, attributes={ "fill": color, "font-size": "18" }, ).add_to(group) bboxes.append(sg.box(*sg.shape(f["geometry"]).bounds)) group.add_to(my_map) fl.LayerControl().add_to(my_map) # Fit map to bounds bounds = so.unary_union(bboxes).bounds bounds2 = [bounds[1::-1], bounds[3:1:-1]] # Folium expects this ordering my_map.fit_bounds(bounds2) return my_map
elif wind['Wind direction'][j]=='西南': x=10; elif wind['Wind direction'][j]=='西南西': x=11; elif wind['Wind direction'][j]=='西': x=12; elif wind['Wind direction'][j]=='西北西': x=13; elif wind['Wind direction'][j]=='西北': x=14; elif wind['Wind direction'][j]=='北北西': x=15; elif wind['Wind direction'][j]=='靜風': x=0; station2.add_child(folium.Marker( location=[wind['Latitude'][j],wind['Longitude'][j]], popup=("<b>NAME:</b> {NAME}<br>""<b>Wind speed:</b> {Windspeed}<br>""<b>Wind direction:</b> {winddirection}<br>""<b>TIME:</b> {TIME}<br>") .format(NAME=str(wind['Sitename'][j]),Windspeed=str(wind['Wind speed'][j]),winddirection=str(wind['Wind direction'][j]),TIME=str(tim$ icon=folium.CustomIcon(wind_icon_url[x],icon_size=(27,27)) ) ) fmap.add_child(station) fmap.add_child(station2) folium.LayerControl().add_to(fmap) # lat/lon to map # folium.LatLngPopup().add_to(fmap) fmap.save('/var/www/html/epa2') #存成 final.html
fgv.add_child( folium.Marker( location=[lt, ln], popup=folium.Popup(iframe), #adding different colors of markers based on elevation #create a function that returns the str based on the elevation icon=folium.Icon(color=color_producer(el)))) #add more dimension to the map - Polygon #add style that colors the map based on population fgp.add_child( folium.GeoJson( data=open('world.json', 'r', encoding='utf-8-sig').read(), #lambda functions are just functions but in a single line style_function=lambda x: { 'fillColor': 'yellow' if x['properties']['POP2005'] < 1000000 else 'oranange' if 1000000 <= x['properties']['POP2005'] < 20000000 else 'red' })) map.add_child(fgv) map.add_child((fgp)) #add an element that tuns on/off these base layers - use layerControl class of folium map.add_child(folium.LayerControl( )) #you dont want to use this because it can turn off all the features #so make separate feature groups for each layer map.save("Map3.html")
for n, lt, ln, el, ty in zip(name, lat, lon, elev, type): #volcano.add_child(folium.Marker(location=[lt,ln], popup=str(el) + "m \nType: " + ty, tooltip = n, icon = folium.Icon(color = elevation_color(el)))) usa_volcano.add_child( folium.CircleMarker(location=[lt, ln], radius=6, popup=str(el) + "m \n Type: " + ty, tooltip=n, fill_color=elevation_color(el), color='grey', fill_opacity=0.9)) # this will access the json file, and will use properties and pop2005 to color code countries based on their population pop.add_child( folium.GeoJson( data=open('world.json', 'r', encoding='utf-8-sig').read(), style_function=lambda x: { 'fillColor': 'darkgreen' if x['properties']['POP2005'] < 10000000 else 'beige' if 10000000 <= x['properties']['POP2005'] < 20000000 else 'red' })) map.add_child(pop) map.add_child(usa_volcano) map.add_child( folium.LayerControl() ) # This will store pop and volcano as different layers that can be turned on and off in the HTML file map.save("Map1.html") # This saves the map as an HTML file called Map1
def makemap(lst): geomap = folium.Map([23.75, 121], zoom_start=8, tiles="cartodbpositron") folium.TileLayer('stamenterrain').add_to(geomap) folium.TileLayer('openstreetmap').add_to(geomap) colors = ["#FFFFFF", "#FFAAAA", "#FF6666","#FF6666", "#FF6666","#FF6666", "#FF0000","#FF0000","#FF0000","#FF0000"] cm = branca.colormap.LinearColormap(colors, vmin=0, vmax=1).to_step(len(colors)) cm.caption = 'EI value' geomap.add_child(cm) sp,*pred = lst dfsp = pd.read_csv("../output_csv/combine/{}.csv".format(sp)) tl1 = get_list(dfsp,2) if len(pred) == 1: pred1 = pd.read_csv("../output_csv/combine/{}.csv".format(pred[0])) tl2 = get_list(pred1,1,ref=True) tl3 = [] elif len(pred) == 2: pred1 = pd.read_csv("../output_csv/combine/{}.csv".format(pred[0])) pred2 = pd.read_csv("../output_csv/combine/{}.csv".format(pred[1])) tl2 = get_list(pred1,1,ref=True) tl3 = get_list(pred2,3,ref=True) else: tl2 = tl3 = [] features = add_station(dfsp,sp) FC = tl1 + tl2 + tl3 + features plugins.TimestampedGeoJson( { 'type': 'Feature', 'features': FC }, period='P1M', duration='P15D', auto_play=False, loop=False, loop_button=True, date_options='YYYY/MM', ).add_to(geomap) plugins.Fullscreen(position='topright', force_separate_button=True).add_to(geomap) plugins.MiniMap().add_to(geomap) plugins.MeasureControl(primary_length_unit='kilometers', secondary_length_unit='meters', primary_area_unit='hectares', secondary_area_unit='sqmeters').add_to(geomap) formatter = "function(num) {return L.Util.formatNum(num, 3) + ' º ';};" plugins.MousePosition( position='bottomleft', separator=' | ', empty_string='NaN', lng_first=True, num_digits=20, prefix='Coordinates:', lat_formatter=formatter, lng_formatter=formatter ).add_to(geomap) geomap.add_child(folium.LayerControl(position="topleft")) # return geomap geomap.save('../html/{}.html'.format(sp))
def main(): ## Creating the base map object map_ = folium.Map(location=[40.2171, -74.7429], zoom_start=5, tiles='stamenwatercolor') def map_save(map_obj=map_, open_=True): map_obj.save("webmap1.html") ## This will control the browser to open up the html file if open_ == True: webbrowser.open_new_tab(os.path.realpath("webmap1.html")) # ------------------------------------------------------------------------------------- ## Adding multiple markers fg1 = folium.FeatureGroup(name="State_Markers") ## Reading in the state lat long dataframe try: ## If the file does not exist in directory df = pd.read_csv("State_Lat_Long.csv") except: ## The function will be called to recall the source data and create the file print("File not in Directory.") df = scraper() print("File Created and loaded") ## This is a csv I created when scraping and editing the json in the AddingPopulationToJson python File population_df = pd.read_csv("State_Population.csv") df['State'] = df["State"].apply(lambda x: x.strip()) #print(df) #print(population_df) df = pd.merge(df, population_df, left_on="State", right_on="State") # df.drop(["Unamed: 0_x", "Unamed: 0_y"], axis = 1, inplace = True) for i, k in df.iterrows(): fg1.add_child( folium.Marker(location=[k[1], k[2]], tooltip="State: {} - Click For Detail".format(k[0]), popup="POP: {} POP_DENSITY: {} (p/m^2)".format( k[3], k[4]), icon=folium.Icon(color='blue'))) # ------------------------------------------------------------------------------------- ## Reading in the state capital data, and appending it to the web map state_df = pd.read_json("us_state_capitals.json", 'index') ## Creating a group to add the next batch of data into fg2 = folium.FeatureGroup(name='State_Capitals') ## Iterating over the rows in dataframe and appending it to the map for i, k in state_df.iterrows(): fg2.add_child( folium.CircleMarker(location=[k[1], k[2]], popup="{}".format(k[0]), tooltip="State Capital - Click for Detail", color='green', fill_color='green', fill_opacity=1)) ## Adding all of the edits to the file # ------------------------------------------------------------------------------------- ## Playing around with volcano data. fg3 = folium.FeatureGroup(name="Volcanoes") with open("Volcanoes.txt", "r") as f: ## Rearding a list of lines from the stream above contents = f.readlines() #[print(i) for i in contents[:5]] df_volcanoes = pd.read_csv("Volcanoes.txt") ## Calculating the range and 3 steps for the elevation values ## This will be used to bin the volcanoes into 3 categories min_ = min(df_volcanoes['ELEV']) max_ = max(df_volcanoes["ELEV"]) range_ = max_ - min_ step_ = range_ / 3 step1 = min_ + step_ step2 = step1 + step_ step3 = step2 + step_ def step_finder(x, step1, step2, step3): """ This function will return colors based on where the value x falls in relation to the 3 bins above """ if x <= step1: return "pink" elif (x <= step2) and (x > step1): return "orange" else: return "red" for i, k in df_volcanoes.iterrows(): color_ = step_finder(float(k[5]), step1, step2, step3) fg3.add_child( folium.CircleMarker( location=[k[8], k[9]], popup="NAME: {} \n\nTYPE: {} \n\nELEVATION: {}".format( k[2], k[4], k[5]), tooltip="Volcano! - Click for Detail", fill_color=color_, color="grey", fill_opacity=0.8)) # ------------------------------------------------------------------------------------- ## Adding polygon layer to the map ## Loading in the geojson data: fg4 = folium.FeatureGroup(name="Country_Polygon") fg4.add_child( folium.GeoJson( data=open("world.json", "r", encoding="utf-8-sig").read())) ## Adding the State Poly to the map: fg5 = folium.FeatureGroup(name="United_State_Population_Chloro_layer") fg5.add_child( folium.GeoJson( data=open("state_updated.json", "r").read(), style_function=lambda x: { "fillColor": "green" if int(x['properties']['Pop']) < 500000 else "yellow" if 500000 <= int(x['properties']['Pop']) < 10000000 else "orange" if 10000000 <= int(x['properties']['Pop'] ) < 25000000 else "red" }, )) ## Inserting them by layer: map_.add_child(fg4) map_.add_child(fg5) map_.add_child(fg1) map_.add_child(fg2) map_.add_child(fg3) ## Adding layer control to the map_ map_.add_child(folium.LayerControl()) # ------------------------------------------------------------------------------------- ## Saving and plotting the map open_map = input("Open map? [y/n] ") if open_map.lower() == 'y': open_map = True else: open_map = False map_save(open_=open_map) return None
for point in dataset['geometry']: CircleMarker(location=[point.y, point.x], radius=4, color=color, fill_color=color).add_to(feature_group) feature_group.add_to(mapname) ### Make map # First create basemap boston_map = folium.Map([latitude, longitude], tiles='Cartodb dark_matter', zoom_start=12) folium.TileLayer('Cartodb Positron').add_to(boston_map) # Create sequence of colors so different layers appear in different colors colors = ['#66c2a5', '#fc8d62', '#8da0cb', '#e78ac3', '#a6d854'] # Plot data as separate layers for i in range(len(match)): data = process_data(match[i][1]) add_layer(data, match[i][0], boston_map, colors[i]) # Add control to toggle between model layers folium.LayerControl(position='bottomright').add_to(boston_map) # Save map as separate html file boston_map.save('plot_points.html')
def map_trips( feed: "Feed", trip_ids: Iterable[str], color_palette: list[str] = cs.COLORS_SET2, *, include_stops: bool = False, include_arrows: bool = False, ): """ Return a Folium map showing the given trips and (optionally) their stops. If any of the given trip IDs are not found in the feed, then raise a ValueError. If ``include_arrows``, then use the Folium plugin PolyLineTextPath to draw arrows on each trip polyline indicating its direction of travel; this fails to work in some browsers, such as Brave 0.68.132. """ # Initialize map my_map = fl.Map(tiles="cartodbpositron") # Create colors n = len(trip_ids) colors = [color_palette[i % len(color_palette)] for i in range(n)] # Collect bounding boxes to set map zoom later bboxes = [] # Create a feature group for each route and add it to the map for i, trip_id in enumerate(trip_ids): collection = trips_to_geojson(feed, [trip_id], include_stops=include_stops) group = fl.FeatureGroup(name=f"Trip {trip_id}") color = colors[i] for f in collection["features"]: prop = f["properties"] # Add stop if present if f["geometry"]["type"] == "Point": lon, lat = f["geometry"]["coordinates"] fl.CircleMarker( location=[lat, lon], radius=8, fill=True, color=color, weight=1, popup=fl.Popup(hp.make_html(prop)), ).add_to(group) # Add trip else: path = fl.PolyLine( [[x[1], x[0]] for x in f["geometry"]["coordinates"]], color=color, popup=hp.make_html(prop), ) path.add_to(group) bboxes.append(sg.box(*sg.shape(f["geometry"]).bounds)) if include_arrows: # Direction arrows, assuming, as GTFS does, that # trip direction equals LineString direction fp.PolyLineTextPath( path, " \u27A4 ", repeat=True, offset=5.5, attributes={ "fill": color, "font-size": "18" }, ).add_to(group) group.add_to(my_map) fl.LayerControl().add_to(my_map) # Fit map to bounds bounds = so.unary_union(bboxes).bounds # Folium wants a different ordering bounds = [(bounds[1], bounds[0]), (bounds[3], bounds[2])] my_map.fit_bounds(bounds) return my_map
def calculate_dis(request): distance = None form = MeasurementModelForm(request.POST or None) geolocator = Nominatim(user_agent="measurement") trak = geocoder.ip('me') ip = trak.ip # ip='47.30.209.199' country, city, lat, long = get_geo(ip) # print("country",country) # print(f"Location {city['city']}, {city['region']}, {city['country_name']}, {city['country_code']}" ) # print("city",) # print('country_code',) # print('region',) # print("lat",lat) # print("lon",long) l_lat = lat l_long = long pointa = (l_lat, l_long) map = folium.Map(location=(l_lat, l_long)) folium.Marker( location=[l_lat, l_long], raduis=5, tooltip= f"{city['city']}, {city['region']}, {city['country_name']}, {city['country_code']}", icon=folium.Icon(color="red")).add_to(map) folium.TileLayer('Mapbox Control Room').add_to(map) folium.TileLayer('Stamen Toner').add_to(map) folium.TileLayer('Stamen Terrain').add_to(map) folium.TileLayer('Stamen Watercolor').add_to(map) folium.TileLayer('CartoDB positron').add_to(map) folium.TileLayer('CartoDB dark_matter').add_to(map) if form.is_valid(): instance = form.save(commit=False) locat = form.cleaned_data.get('Location') location = geolocator.geocode(locat) # print(location) l_lat = location.latitude l_long = location.longitude pointa = (l_lat, l_long) map = folium.Map(location=(l_lat, l_long)) folium.Marker( location=[l_lat, l_long], raduis=5, tooltip= f"{city['city']}, {city['region']}, {city['country_name']}, {city['country_code']}", icon=folium.Icon(color="red")).add_to(map) folium.TileLayer('Mapbox Control Room').add_to(map) folium.TileLayer('Stamen Toner').add_to(map) folium.TileLayer('Stamen Terrain').add_to(map) folium.TileLayer('Stamen Watercolor').add_to(map) folium.TileLayer('CartoDB positron').add_to(map) folium.TileLayer('CartoDB dark_matter').add_to(map) # print("##",location) dest = form.cleaned_data.get('Destination') destination = geolocator.geocode(dest) # print("Destination",destination) if destination == None: messages.error(request, "Check the Destination Location then Try Again") else: d_lat = destination.latitude d_lon = destination.longitude pointb = (d_lat, d_lon) distance = round(geodesic(pointa, pointb).km, 2) map = folium.Map(location=cords(l_lat, l_long, d_lat, d_lon), zoom_start=zooming(distance)) folium.Marker( location=[l_lat, l_long], raduis=5, tooltip= f"{city['city']}, {city['region']}, {city['country_name']}, {city['country_code']}", icon=folium.Icon(color="red")).add_to(map) folium.Marker(location=[d_lat, d_lon], raduis=5, tooltip=dest, icon=folium.Icon(color="blue")).add_to(map) folium.TileLayer('Mapbox Control Room').add_to(map) folium.TileLayer('Stamen Toner').add_to(map) folium.TileLayer('Stamen Terrain').add_to(map) folium.TileLayer('Stamen Watercolor').add_to(map) folium.TileLayer('CartoDB positron').add_to(map) folium.TileLayer('CartoDB dark_matter').add_to(map) folium.PolyLine(locations=(pointa, pointb), weight=5, tooltip=f"Distance is {distance}km", color='blue').add_to(map) instance.Location = location instance.Distance = distance instance.save() map.add_child(folium.LayerControl()) map = map._repr_html_() context = { # 'distane_obj':obj, 'Distance': Mes.objects.last(), 'form': form, 'map': map, } return render(request, 'index.html', context)
for lt, ln, el in zip(lat, lon, ele): # marker adder colorr = color_picker(el) fgv.add_child( folium.CircleMarker(location=[lt, ln], radius=10, color='grey', fill_color=color_picker(el), fill=True, fill_opacity=0.7, popup="%s m" % (el), icon=folium.Icon(color=colorr, icon='hashtag', prefix='fa'))) fgp = folium.FeatureGroup(name="Population") fgp.add_child( folium.GeoJson( data=open('world.json', 'r', encoding='utf-8-sig').read(), style_function=lambda x: { 'fillColor': 'green' if x['properties']['POP2005'] < 10000000 else 'orange' if 10000000 <= x['properties']['POP2005'] < 20000000 else 'red' })) # Data from the world json and use the style function map1.add_child(fgv) map1.add_child(fgp) map1.add_child(folium.LayerControl()) # Looks for childs map1.save("map1.html")
# for row in state_data : m = folium.Map(location=[36, 127], tiles="OpenStreetMap", zoom_start=7) # folium.Map(location=[37.566345, 126.977893], zoom_start=17, tiles='Stamen Terrain') # folium.Map(location=[37.566345, 126.977893], zoom_start=17, tiles='Stamen Toner') # folium.Marker([37.566345, 126.977893], popup='서울특별시청').add_to(map_osm) # folium.Marker([37.5658859, 126.9754788], popup='덕수궁').add_to(map_osm) # folium.Marker([37.566345, 126.977893], popup='서울특별시청', icon=folium.Icon(color='red',icon='info-sign')).add_to(map_osm) # folium.CircleMarker([37.5658859, 126.9754788], radius=100,color='#3186cc',fill_color='#3186cc', popup='덕수궁').add_to(map_osm) m.choropleth( geo_data=state_geo, name='choropleth', data=state_data, columns=['Code', 'Population'], key_on='feature.properties.CTPRVN_CD', fill_color='PuRd', fill_opacity=0.7, line_opacity=0.5, legend_name='Population Rate (%)' ) folium.LayerControl().add_to(m) m.save('folium_kr.html') webbrowser.open_new("folium_kr.html")
def generate_map(week, logos_enabled=True, schools_enabled=False): CENTER = (39.8283, -98.5795) DEFAULT_ZOOM = 4 geojson_filename = dir / "json" / str(year) / "week{}.json".format(week) map = folium.Map(location=CENTER, tiles='CartoDB positron', zoom_start=DEFAULT_ZOOM) def style(feature): return { 'fillOpacity': .85, 'fillColor': feature['color'], 'weight': 0.75, 'color': 'black' } def draw_counties(geojson_filename): folium.GeoJson(data=str(geojson_filename), name='geojson', style_function=style).add_to(map) def draw_schools(): for i in range(len(schools.values)): popup = folium.Popup(schools['School'][i], parse_html=True) location = [schools['Lat'][i], schools['Long'][i]] folium.Marker(location, popup=popup).add_to(map) def draw_logos(): clusters = find_clusters() for i in range(len(clusters)): location = [clusters['Lat'][i], clusters['Long'][i]] icon = folium.features.CustomIcon(icon_image=clusters['Logo'][i], icon_size=(35, 35), icon_anchor=None) folium.Marker(location=location, tooltip=clusters['School'][i], icon=icon).add_to(map) def find_clusters(): school_clusters = [] school_names = [] logos = [] for i in range(len(school_centroids)): k = schools['K'][i] if k != 0: cluster, _ = kmeans(school_centroids[i], k) for j in range(len(cluster)): school_clusters.append(cluster[j]) school_names.append(schools['School'][i]) logos.append(schools['Logo'][i]) school_clusters = np.array(school_clusters) return pd.DataFrame({ "Lat": school_clusters[:, 0], "Long": school_clusters[:, 1], "School": school_names, "Logo": logos }) draw_counties(dir / "json" / str(year) / "week{}.json".format(week)) folium.LayerControl().add_to(map) if (logos_enabled): draw_logos() if (schools_enabled): draw_schools() map.save( str(dir / "output_maps" / str(year) / "map_week{}.html".format(week)))
elev = list(data["ELEV"]) #return a different color for markers based on height def color_producer(elevation): if elevation<1000: return 'green' elif elevation>=1000 and el<3000: return 'orange' else: return 'red' map =folium.Map(location = [38.2,-99.1],zoom_start=5,tiles="Mapbox Bright") fgv = folium.FeatureGroup(name="Volcanoes") for lt,ln,el in zip(lat,lon,elev): fgv.add_child(folium.CircleMarker(location=[lt,ln], radius=5, popup = str(el) + " m", color='grey',fill_color=color_producer(el))) fgp = folium.FeatureGroup(name="Population") fgp.add_child(folium.GeoJson(data=open('world.json', 'r', encoding='utf-8-sig'), style_function=lambda x: {'fillColor':'green' if x['properties']['POP2005'] < 10000000 else 'orange' if 10000000 <= x['properties']['POP2005'] < 20000000 else 'red'})) map.add_child(fgp)#each feature group object is a layer,fgv has all volcano objects and fgp with population ones map.add_child(fgv) map.add_child(folium.LayerControl())#refers to the fgv and fgp layers which are added to map each layers refers to the name mentioned when initializing it map.save("Map1.html")
def seiu(lat, lon, time): print("") # request reverse geocoding r = requests.get( 'https://api.opencagedata.com/geocode/v1/json?q=%s+%s&key=7e95a1a406154911b68bfff0a5bf9c34' % (lat, lon)) results = r.json() where = results['results'][0]['formatted'] print("Your location is:", where) # load csv df_ca = pd.read_csv('supporting documents/Dialysis_CA.csv') df_la = pd.read_csv('supporting documents/Dialysis_LA.csv') df_seiu = pd.read_csv('supporting documents/SEIU_UHW_CA.csv') # handle lat lon as floats df_seiu['lat'] = df_seiu['lat'].astype(float) df_seiu['lon'] = df_seiu['lon'].astype(float) df_ca['lat'] = df_ca['lat'].astype(float) df_ca['lon'] = df_ca['lon'].astype(float) df_la['lat'] = df_la['lat'].astype(float) df_la['lon'] = df_la['lon'].astype(float) # map map = folium.Map(location=[36.7783, -119.4179], tiles='Stamen Toner', zoom_start=5.5) # plugin for MeasureControl map.add_child(MeasureControl()) # float image plugin for logo logo = ('https://i.imgur.com/WTmLCbc.png') justice = ('https://i.imgur.com/mJgkwHV.png') FloatImage(logo, bottom=8, left=4).add_to(map) FloatImage(justice, bottom=.5, left=4).add_to(map) fg = folium.FeatureGroup(name='Heat Map of Dialysis Clinics').add_to(map) heat_df = df_ca[['lat', 'lon']] heat_data = [[row['lat'], row['lon']] for index, row in heat_df.iterrows()] HeatMap(heat_data, radius=15, blur=17).add_to(fg) # clinics in CA clinic_df = df_ca[['lat', 'lon']] clinic_data = [[r['lat'], r['lon']] for i, r in clinic_df.iterrows()] fg_1 = folium.FeatureGroup(name='Dialysis Clinics').add_to(map) marker_cluster = MarkerCluster().add_to(fg_1) for point in range(0, len(clinic_data)): folium.Marker(clinic_data[point], popup='<strong>' + "Facility: " + df_ca['Facility N'][point] + " - Address:" '</strong>' + df_ca['Address Li'][point], icon=folium.Icon(color='beige', icon_color='darkpurple', icon='plus')).add_to(marker_cluster) # SEIU offices seiu_df = df_seiu[['lat', 'lon']] seiu_data = [[r['lat'], r['lon']] for i, r in seiu_df.iterrows()] fg_2 = folium.FeatureGroup(name='SEIU UHW Offices').add_to(map) for point in range(0, len(seiu_data)): folium.Marker(seiu_data[point], popup='<strong>' + "SEIU Office: " + df_seiu['SEIU UHW'][point] + " - Address:" '</strong>' + df_seiu['Address'][point], icon=folium.Icon(color='darkpurple', icon_color='white', icon='heart')).add_to(fg_2) folium.LayerControl(collapsed=False).add_to(map) map.save('MapFinal1.html') # Service Area loc = [[lon, lat]] loc_df = pd.DataFrame(loc, columns=['lon', 'lat']) org_df = loc_df[['lat', 'lon']] org_data = [[r['lat'], r['lon']] for i, r in org_df.iterrows()] map2 = folium.Map(location=[float(lat), float(lon)], tiles='Stamen Toner', zoom_start=11) FloatImage(logo, bottom=8, left=4).add_to(map2) FloatImage(justice, bottom=.5, left=4).add_to(map2) for point in range(0, len(org_data)): folium.Marker(org_data[point], popup='<strong>' "Your Input Location:" + where + '</strong>', icon=folium.Icon(color='darkpurple', icon_color='white', icon='user')).add_to(map2) key = '5b3ce3597851110001cf6248c13297498fc24a73a4067bd7d1a87f7d' clnt = client.Client(key=key) # parameters for isochrones request params_iso = { 'profile': 'driving-car', 'range': [time * 60], 'interval': time * 60 } loc_dict = {'loc': {'location': [lon, lat]}} for name, loc in loc_dict.items(): params_iso['locations'] = [loc['location']] iso = clnt.isochrones(**params_iso) folium.features.GeoJson(iso).add_to(map2) iso_buffer = Polygon(iso['features'][0]['geometry']['coordinates'][0]) folium.features.GeoJson(data=mapping(iso_buffer), name='Drive Time Isochrone', overlay=True).add_to(map2) # reverse lat lon df clinic_r_a = df_ca[['lat', 'lon', 'Address Li', 'Facility N']] clinic_r_a_data = [[r['lon'], r['lat'], r['Address Li'], r['Facility N']] for i, r in clinic_r_a.iterrows()] print("") print("Clinics within" + " " + str(time) + " " + "minute(s) of driving" + ": ") print("") for clinic in clinic_r_a_data: point = Point(clinic) if iso_buffer.contains(point): omglol = clinic[3] + " at " + clinic[2] folium.Marker(list(reversed(point.coords[0])), popup='<strong>' + "Clinics within" + " " + str(time) + " " + "minute(s) of driving" + '</strong>' + ": " + omglol, icon=folium.Icon(color='beige', icon_color='darkpurple', icon='plus')).add_to(map2) params_route = { 'profile': 'driving-car', 'format_out': 'geojson', 'geometry': 'true', 'format': 'geojson', 'instructions': 'true', 'preference': 'recommended' } def style_function(color): return lambda feature: dict(color=color, weight=3, opacity=1) for clinic in clinic_r_a_data: point = Point(clinic) for name, loc in loc_dict.items(): org_coord = loc['location'] if iso_buffer.contains(point): omglol = clinic[3] + " at " + clinic[2] clinic_coord = [clinic[0], clinic[1]] params_route['coordinates'] = [org_coord, clinic_coord] json_route = clnt.directions(**params_route) folium.features.GeoJson( json_route, style_function=style_function("#ffff00")).add_to(map2) folium.Marker(list(reversed(point.coords[0])), popup='<strong>' + "Clinics within" + " " + str(time) + " " + "minute(s) of driving" + '</strong>' + ": " + omglol, icon=folium.Icon(color='beige', icon_color='darkpurple', icon='plus')).add_to(map2) print(omglol) print("Driving distance in minute(s):") print( (json_route['features'][0]['properties']['summary']['duration'] ) / 60) print("") map2.save('MapFinal2.html')
import folium import pandas data = pandas.read_csv("Volcanoes.txt") lat = list(data["LAT"]) lon = list(data["LON"]) elev = list(data["ELEV"]) def color_producer(elevation): if ele<=2000: return 'green' elif ele>2000 and ele<=3000: return 'orange' else: return 'red' map = folium.Map(location=[38.58, -99.09],zoom_start =6) fg = folium.FeatureGroup(name = "MyMap") for lt, ln, ele in zip(lat,lon,elev): fg.add_child(folium.CircleMarker(location=[lt, ln], popup=str(ele)+"m", fill_color = color_producer(ele), color = 'grey', fill_opacity =0.7)) fg.add_child(folium.GeoJson(data = open('world.json','r',encoding = 'utf-8-sig').read(), style_function = lambda x:{'fillColor':'yellow'})) map.add_child(fg) map.add_child(folium.LayerControl()) map.save("Map1.html")
def _map_images( plot_file_format: List[str], result_df: GeoDataFrame, filepaths: List[Union[str, Path]], aoi: GeoDataFrame = None, show_images=True, show_features=False, name_column: str = "id", save_html: Path = None, ) -> folium.Map: """ Displays data.json, and if available, one or multiple results geotiffs. Args: plot_file_format: List of accepted image file formats e.g. [".png"] result_df: GeoDataFrame with scene geometries. aoi: GeoDataFrame of aoi. filepaths: Paths to images to plot. Optional, by default picks up the last downloaded results. show_images: Shows images if True (default). show_features: Show features if True. For quicklooks maps is set to False. name_column: Name of the feature property that provides the Feature/Layer name. save_html: The path for saving folium map as html file. With default None, no file is saved. """ if result_df.shape[0] > 100: result_df = result_df.iloc[:100] logger.info( "Only the first 100 results will be displayed to avoid memory " "issues.") centroid = box(*result_df.total_bounds).centroid m = folium_base_map( lat=centroid.y, lon=centroid.x, ) df_bounds = result_df.bounds list_bounds = df_bounds.values.tolist() raster_filepaths = [ path for path in filepaths if Path(path).suffix in plot_file_format ] try: feature_names = result_df[name_column].to_list() except KeyError: feature_names = [""] * len(result_df.index) if aoi is not None: aoi_style = VECTOR_STYLE.copy() aoi_style["color"] = "red" folium.GeoJson( aoi, name="aoi", style_function=lambda x: aoi_style, highlight_function=lambda x: HIGHLIGHT_STYLE, ).add_to(m) if show_features: for idx, row in result_df.iterrows(): # type: ignore try: feature_name = row.loc[name_column] except KeyError: feature_name = "" layer_name = f"Feature {idx + 1} - {feature_name}" f = folium.GeoJson( row["geometry"], name=layer_name, style_function=lambda x: VECTOR_STYLE, highlight_function=lambda x: HIGHLIGHT_STYLE, ) folium.Popup( f"{layer_name}: {row.drop('geometry', axis=0).to_json()}" ).add_to(f) f.add_to(m) if show_images and raster_filepaths: for idx, (raster_fp, feature_name) in enumerate( zip(raster_filepaths, feature_names)): with rasterio.open(raster_fp) as src: if src.meta["crs"] is None: dst_array = src.read()[:3, :, :] minx, miny, maxx, maxy = list_bounds[idx] else: # Folium requires 4326, streaming blocks are 3857 with WarpedVRT(src, crs="EPSG:4326") as vrt: dst_array = vrt.read()[:3, :, :] minx, miny, maxx, maxy = vrt.bounds m.add_child( folium.raster_layers.ImageOverlay( np.moveaxis(np.stack(dst_array), 0, 2), bounds=[[miny, minx], [maxy, maxx]], # different order. name=f"Image {idx + 1} - {feature_name}", )) # Collapse layer control with too many features. collapsed = bool(result_df.shape[0] > 4) folium.LayerControl(position="bottomleft", collapsed=collapsed).add_to(m) if save_html: save_html = Path(save_html) if not save_html.exists(): save_html.mkdir(parents=True, exist_ok=True) filepath = save_html / "final_map.html" with filepath.open("w") as f: f.write(m._repr_html_()) return m