def add_points_AB2(mapobj, gdf, popup_field_list): #Source: https://github.com/python-visualization/folium/pull/376 #Source IMP: https://github.com/python-visualization/folium/blob/master/examples/MarkerCluster.ipynb # Create empty lists to contain the point coordinates and the point pop-up information coords, popups = [], [] # Loop through each record in the GeoDataFrame for i, row in gdf.iterrows(): # Append lat and long coordinates to "coords" list coords.append([row.geometry.y, row.geometry.x]) # Create a string of HTML code used in the IFrame popup # Join together the fields in "popup_field_list" with a linebreak between them label = '<br>'.join([field + ': ' + str(row[field]) for field in popup_field_list]) popups.append(label) icon_create_function = """\ function(cluster) { return L.divIcon({ html: '<b>' + cluster.getChildCount() + '</b>', className: 'marker-cluster marker-cluster-large', iconSize: new L.Point(20, 20) }); }""" marker_cluster = MarkerCluster( locations=coords, popups=popups, name='1000 clustered icons', overlay=True, control=True, icon_create_function=icon_create_function) marker_cluster.add_to(mapobj) folium.LayerControl().add_to(mapobj) return mapobj
def FoliumMap(df_): ''' Function creates a new, empty map with folium, the map doesnt contain any datapoints yet but is intialized at the mean latitude & longitude point in our dataset. Then adds data points = flats (markers) to the map. For each observation (=row) of the dataset we read the latitude & longitude to create an icon which will be a display for the flat on the map. Furthermore we add a pop up text with basic information about the flat to each icon. We create clusters to achieve better visualisation. ''' new_map = folium.Map( location=[df_['latitude'].mean(), df_['longitude'].mean()], zoom_start=12, tiles='cartodbpositron') mc = MarkerCluster() # create empty cluster object for row in tqdm(df_.itertuples()): mc.add_child( folium.Marker( location=[row.latitude, row.longitude], #create markers and add to cluster popup=folium.Popup( folium.IFrame(('''Size: {Size} <br> m2: {m2} <br> Base Price: {bp} <br> Utilities: {up} <br> Total Price: {TotalPrice}''').format(Size=row.Size, m2=row.m2, bp=row[5], up=row[6], TotalPrice=row[7]), width=200, height=100)), icon=folium.Icon(icon='home'))) #define icon symbol new_map.add_child(mc) new_map.save(outfile='folium_map.html' ) #saves file as html file in working directory return new_map
def get_friends_locations(user_screen_name, bearer_token) -> str: ''' Gets user name from twitter, returns name of file with created html map. ''' data = get_friends_list(user_screen_name, bearer_token) try: info_on_users = [(user['name'], user['location']) for user in data['users']] except KeyError: return None points_to_put_on_map = [(name, get_location(address)) for name, address in info_on_users] points_to_put_on_map = [(name, tuple(map(float, coordinates))) for name, coordinates in points_to_put_on_map if coordinates] locations_map = folium.Map(tiles='stamenterrain') friends = MarkerCluster() for name, coordinates in points_to_put_on_map: folium.Marker(coordinates, popup=name, icon=folium.Icon(color='red')).add_to(friends) friends.add_to(locations_map) return locations_map # folium Map instance
def plot_geometry(geometry, marker_cluster=False): """ Plot geometries in Folium Parameters: geometry (shapely.geometry.LineString/Point or geopandas.GeoSeries) Example: lat = [40.732605, 40.732612, 40.732255, 40.731856, 40.731469] lon = [-73.99607, -73.996087, -73.996351, -73.996639, -73.996932] t = LineString([[lon, lat] for lat, lon in zip(lat, lon)]) plot_linestring(t) """ if (type(geometry) != gpd.GeoSeries): geometry = gpd.GeoSeries(geometry) geometry_ = geometry.geometry[0] initial_coords = [geometry_.xy[1][0], geometry_.xy[0][0]] map_ = folium.Map(initial_coords, zoom_start=14) geometries_json = json.loads(geometry.to_json()) geometries_geojson = folium.features.GeoJson(geometries_json) if (marker_cluster == True): # exclusively for points plot mc = MarkerCluster() mc.add_child(geometries_geojson) map_.add_child(mc) else: map_.add_child(geometries_geojson) return map_
def build_html_for(execution_date, conn, credentials): sql_query = build_query_for(execution_date.year, execution_date.month) logging.info(sql_query) df = sqlio.read_sql_query(sql_query, conn) if df.empty: logging.info('Query returned empty results set') return pickup_map = Map( location=[df['pickup_latitude'].mean(), df['pickup_longitude'].mean()], tiles='OpenStreetMap', zoom_start=12) mc = MarkerCluster() for row in df.itertuples(): mc.add_child( folium.Marker(location=[row.pickup_latitude, row.pickup_longitude], popup=str(row.pickup_latitude) + ',' + str(row.pickup_longitude))) pickup_map.add_child(mc) html_file_name = "{}-{}_pickups_map.html".format(execution_date.year, execution_date.month) pickup_map.save(outfile=html_file_name) upload_file_to_s3( html_file_name, "data-sprints-eng-test/outputs/monthly/{}".format(html_file_name), credentials, "text/html") os.remove(html_file_name)
def makeSearchMapData(): mask_store_info = getNearMaskStoreInfo(CoronaMaskList.addr) data_for_draw3 = mask_store_info.loc[:, [ 'name', 'latitude', 'longitude', 'remain_stat' ]] data_for_draw_except_nan3 = data_for_draw3.dropna() data_for_draw_except_nan3 = data_for_draw_except_nan3[ data_for_draw_except_nan3['remain_stat'] != 'break'] x = data_for_draw_except_nan3.loc[[1], ['latitude']].values y = data_for_draw_except_nan3.loc[[1], ['longitude']].values map_hs3 = folium.Map((x, y), zoom_start=14) mc3 = MarkerCluster() names = list(data_for_draw_except_nan3['name']) latitudes = list(data_for_draw_except_nan3['latitude']) longitudes = list(data_for_draw_except_nan3['longitude']) remain_stats = list(data_for_draw_except_nan3['remain_stat']) for i in tqdm(range(len(names))): mc3.add_child( folium.Marker(location=[latitudes[i], longitudes[i]], icon=folium.Icon(color=color_dic[remain_stats[i]]), popup=names[i] + ' ' + remain_stat_kor[remain_stats[i]])) map_hs3.add_child(mc3) map_hs3.save("./mask_store4.html") webbrowser.open_new('mask_store4.html') #executeMaskMap()
def create_map(): df = load_data() latitude = df['latitude'] longitude = df['longitude'] popups = df['comment'] n_rivals = df['n_rivals'] vmax = df['n_rivals'].max() m = folium.Map(location=[55.7522, 37.6156]) marker_cluster = MarkerCluster() marker_cluster.add_to(m) folium.LayerControl().add_to(m) for lat, lon, popup, n_rival in zip(latitude, longitude, popups, n_rivals): if 'Калейдоскоп' in popup: popup = 'burgerking\nг.Москва, Химкинский бульвар, д. 7/23 ТЦ Калейдоскоп, 4 этаж\nКонкурентов: 3' folium.Marker(location=[lat, lon], popup=popup, icon=folium.Icon( color=color_change(n_rival))).add_to(marker_cluster) colormap = StepColormap(['green', 'blue', 'orange', 'red'], vmin=0, vmax=vmax, index=[0, 1, 4, 8, vmax]).scale(0, vmax) today = date.today() colormap.caption = f'Количество конкурентов ({today.strftime("%B, %Y")})' colormap.add_to(m) m.save("Moscow_Map.html")
def create_map(jdata, center_coords): # Loads data from csv into pandas dataframe with open("yelp_businesses.json") as f: jdata = json.loads(f.read()) center_coords = jdata["region"]["center"]["latitude"], \ jdata["region"]["center"]["longitude"] df = pd.read_json(json.dumps(jdata["health"])) df.head(2) # print(df.head(3)) # creates an empty map zoomed in Rome print(center_coords) working_map = folium.Map(location=center_coords, zoom_start=12) # creates a marker cluster cluster = MarkerCluster().add_to(working_map) # Add markers to cluster, iterating over dataframe for index, row in df.iterrows(): folium.Marker( location=[ row["coordinates"]["latitude"], row["coordinates"]["longitude"] ], popup="{0}: {1} stars".format(row["name"], row["rating"]), icon=folium.Icon(color='green', icon='ok-sign'), ).add_to(cluster) cluster.add_to(working_map) display(working_map) working_map.save(outfile="../templates/map.html")
def update_map(): m_1 = folium.Map(location=[40.415157, -3.689048], tiles='openstreetmap', zoom_start=10) y, x = connect("datamad1019", "swimming-pools") aggResult = x.find({}) df2 = pd.DataFrame(list(aggResult)) df2.head() mc = MarkerCluster() for idx, row in df2.iterrows(): if not math.isnan(row['Location']["cordinates"][1]) and not math.isnan( row['Location']["cordinates"][0]): link = '<a href=' + f'{row["Google_link"]}' + 'target="_blank">' + 'Satellite View' + '</a>' mc.add_child( Marker([ row['Location']["cordinates"][1], row['Location']["cordinates"][0] ], popup=folium.Popup(link))) m_1.add_child(mc) embed_map(m_1, "./templates/map.html") print( "New map generated. Please restart application to see new swimming pools." ) return m_1
def create_potential_duplicates_map(base_map, near_duplicates: pd.DataFrame): if near_duplicates is None: return marker_cluster = MarkerCluster(control=False) marker_cluster.add_to(base_map) sub_group = FeatureGroupSubGroup(marker_cluster, name='Near-Duplicate Locations', control=True, show=True) # # add markers # ['LocationA', 'NameA', 'coordinatesA', 'LocationB', 'NameB', 'coordinatesB', 'dist_m'] for ix, row in near_duplicates.iterrows(): for is_row_a in [True, False]: dup_location_marker(row, is_row_a).add_to(sub_group) # add lines folium.PolyLine((row.coordinatesA, row.coordinatesB), color="red", weight=2.5, opacity=1).add_to(sub_group) sub_group.add_to(base_map) return None
def add_markers_as_cluster(self, list_objs): """ :param list_objs: dictionary of stations.handler.List :param group_name: :return: """ for list_name, item in list_objs.items(): fg = self.get_group(name=list_name, add_to_map=True, return_group=True) mc = MarkerCluster() for idx in range(item.length): html_obj = self.get_html_object(item, idx) popup = self.get_popup(html_obj) marker = self.get_marker( [item.get('lat_dd')[idx], item.get('lon_dd')[idx]], popup=popup, icon=folium.Icon( color='blue' if list_name == 'master' else 'red', icon='map-marker'), tooltip=item.get('statn')[idx] or 'Click me!') marker.add_to(mc) mc.add_to(fg)
def add_markers_as_cluster(self, stations_list): """ :param stations_dict: :return: """ fg = self.get_group(name='stations', add_to_map=True, return_group=True) mc = MarkerCluster() for statn_dict in stations_list: if statn_dict.get('stationName') and statn_dict.get( 'wgs84Latitude') and statn_dict.get('wgs84Longitude'): html_obj = self.get_html_object(statn_dict) popup = self.get_popup(html_obj) marker = self.get_marker( [ statn_dict.get('wgs84Latitude'), statn_dict.get('wgs84Longitude') ], popup=popup, icon=folium.Icon( color='blue' if statn_dict.get('stationIdentityTypeKey' ) == 'oceanografisktNummer' else 'green' if statn_dict. get('stationIdentityTypeKey') == 'klimatnummer' else 'red'), tooltip=statn_dict.get('stationName') or 'Click me!') marker.add_to(mc) mc.add_to(fg)
def generate_map(): bike_service_proxy = BikeServiceProxy() bikes_map = folium.Map(location=GDANSK_CENTER_POSITION, zoom_start=10) markers_cluster = MarkerCluster() with open(PATH_TO_LOCATIONS, mode='r') as locations_file: locations_reader = csv.DictReader(locations_file) for station_row in locations_reader: available_bikes = get_available_bikes_number(station_row) if available_bikes > 0: available_bikes_ids = get_available_bikes_ids(station_row) coordinates = get_coordinates(station_row) for bike_id in available_bikes_ids: battery_level = bike_service_proxy.battery_info_for_bike( bike_id) battery_info = get_battery_level_info(battery_level) marker_color = get_marker_color(battery_level) bike_marker = prepare_bike_marker(coordinates, bike_id, battery_info, marker_color) markers_cluster.add_child(bike_marker) bikes_map.add_child(markers_cluster) bikes_map.save('bikes_map.html')
def customers(request): starting_Lat = 40.610870 starting_Long = -73.962158 map_hooray = folium.Map( location=[starting_Lat, starting_Long], tiles="OpenStreetMap", zoom_start=12, max_zoom=12, ) folium.Marker( location=[starting_Lat, starting_Long], icon=folium.Icon(color='black', icon='star'), ).add_to(map_hooray) all_lat = Transaction.objects.values('lat') all_long = Transaction.objects.values('long') mc = MarkerCluster() for i in range(len(all_lat)): mc.add_child( folium.Marker( location=[all_lat[i].get('lat'), all_long[i].get('long')])) map_hooray.add_child(mc) folium.plugins.Fullscreen(position='topright', title='Full Screen', title_cancel='Exit Full Screen', force_separate_button=True).add_to(map_hooray) context = {'map': map_hooray._repr_html_()} return render(request, 'inventory/customers.html', context)
def addMarkers(m, df, variable, unit): normalized = normalize(df[variable]) mc = MarkerCluster(name=variable+unit, options={'spiderfyOnMaxZoom':'False', 'disableClusteringAtZoom' : '4'}) for i in range(len(df)): folium.CircleMarker(location=[df.lat[i], df.lon[i]], radius=(normalized[i] * 10), tooltip='%s: %f%s <br> date: %s' % (variable, df[variable][i], unit, df['time'][i]), color='darkOrange', fill=True).add_to(mc) mc.add_to(m) return m
def map_wells(wh): latitude = 54.73 longitude = -117.52704 wells_map = folium.Map(location=[latitude, longitude], zoom_start=5) mc = MarkerCluster() # add markers to map for row in wh.itertuples(): mc.add_child( folium.CircleMarker( #label = 'UWI: {}<br> Formation: {}<br> Current Operator: {}'.format(row.UWI,row.Formation,row.CurrentOperator) #label = folium.Popup(label,parse_html=False) location=[row.Surf_Latitude, row.Surf_Longitude], radius=3, popup= 'UWI: {uwi}<br>Formation: {formation}<br>Current Operatonr:{currentop}' .format(uwi=row.UWI, formation=row.Formation, currentop=row.CurrentOperator) #popup=label, #color='blue', #fill=True, #parse_html=False, #fill_opacity=0.7, )) wells_map.add_child(mc) #wells_map.save('wells.html’) return (wells_map)
def add_radius_circles_as_cluster(self, list_objs): """ :param list_objs: dictionary of stations.handler.List :param group_name: :return: """ for list_name, item in list_objs.items(): fg = self.get_group(name='-'.join([list_name, 'radius']), add_to_map=True, return_group=True) mc = MarkerCluster() check = False for idx in range(item.length): if item.has_attribute('radius'): if item.get('radius')[idx]: check = True folium.Circle( tuple([ item.get('lat_dd')[idx], item.get('lon_dd')[idx] ]), radius=int(item.get('radius')[idx]), fill_color='#3186cc', weight=.5, ).add_to(mc) if check: mc.add_to(fg)
def build_addr_folium_map(df_addr_geo, group_col, marker_data, icon_prop_dict, latlon_cols=('latitude', 'longitude'), color_dict=None, color_col=None): a_folium_map = folium.Map( location=df_addr_geo[list(latlon_cols)].mean(axis=0).tolist(), zoom_start=12) locations = dict() popups = dict() icons = dict() # we create 3 groups for layer to be displayed for group in df_addr_geo[group_col].unique(): locations[group] = list() popups[group] = list() icons[group] = list() cluster = df_addr_geo.loc[df_addr_geo[group_col] == group] mc = MarkerCluster( name=group, options={ "spiderfyOnMaxZoom": True, "removeOutsideVisibleBounds": True, "singleMarkerMode": False, "showCoverageOnHover": True, #"disableClusteringAtZoom": 18, }) cols = marker_data + ['latitude', 'longitude'] if color_col is not None: cols.append(color_col) for el in cluster[cols].to_dict(orient='records'): frame_body_template = '' for data_name in marker_data: frame_body_template += f'<h3>{data_name} : ' frame_body_template += str(el[data_name]) + '<h3>' iframe = folium.IFrame(html=frame_body_template, width=300, height=300) popup = folium.Popup(iframe) location = [el.get(latlon_cols[0]), el.get(latlon_cols[1])] icon_prop = icon_prop_dict[group] if color_dict is not None: icon_prop.update({ "color": color_dict.get(el.get(color_col, None), 'black') }) icon = folium.Icon(**icon_prop) locations[group].append(location) popups[group].append(popup) icons[group].append(icon) mc.add_child( folium.Marker(location=location, popup=popup, icon=icon)) a_folium_map.add_child(mc) a_folium_map.add_child(folium.LayerControl()) return a_folium_map
def generate_base_map(gdf): """[summary] creates a base map for use in building Naptan maps. Args: gdf ([geopandas data]): [description] map_name ([str]): [str identify of the map] Returns: [type]: [description] """ gm = folium.Map( location=[gdf["Latitude"].mean(), gdf["Longitude"].mean()], zoom_start=11, prefer_canvas=True, zoom_control=True, control_scale=True, ) # add measure control with km and area return calculations. gm.add_child( MeasureControl( position="bottomright", primary_length_unit="kilometers", secondary_length_unit="miles", secondary_area_unit="acres", primary_area_unit="sqmeters", )) # added lat long pop up for reference folium.LatLngPopup().add_to(gm) # clustering added mc = MarkerCluster().add_to(gm) # add the popups with relevant data for row in gdf.itertuples(): html = f"""<!DOCTYPE html><div class="boxed"> <b>ATCOCode:</b> <i>{row.ATCOCode}</i><br> <b>StopType:</b> <i>{row.StopType}</i><br> <b>StopPoint:</b> <i>{row.StopPoint}</i><br> <b>Coordinates:</b> <i>{row.Latitude}, {row.Longitude}</i><br> <b>Locality_Name:</b> {row.LocalityName}<br> <b>AreaName:</b> <i>{row.AreaName}</i><br> </div> """ # add the markers to the marker cluster. mc.add_child( folium.Marker( location=[row.Latitude, row.Longitude], popup=html, radius=8, icon=folium.Icon(color="green", prefix="fa-", icon="ok-sign"), )) # add layer control. folium.LayerControl(collapsed=False, position="topright").add_to(gm) # get name of the mapped area. map_name = gdf.AreaName.iloc[0] # save the map save_generated_map(mc, map_name=map_name) return gm
def gen_map(self): # read database connection = sqlite3.connect("posts.db") cursor = connection.cursor() sql = f"""SELECT * FROM "{self.handle}" """ cursor.execute(sql) result = cursor.fetchall() connection.close() # Generate map, cluster class and create empty coordinates list if self.handle == "4x4theboiz": my_map = Map(location=[-25.25, 21.2], zoom_start=5) elif self.handle == "teampolarsteps": my_map = Map(location=[52.35, 5.3], zoom_start=9) elif self.handle == "cityofcapetown": my_map = Map(location=[-34.1, 18.420], zoom_start=10) elif self.handle == "backpackingtours": my_map = Map(location=[10, 100], zoom_start=3) elif self.handle == "tony_ontheroad": my_map = Map(location=[38.5, -2.75], zoom_start=6) elif self.handle == "rolling_sloane": my_map = Map(location=[55, 2.64], zoom_start=4) elif self.handle == "cape_secrets": my_map = Map(location=[-33.4, 18.8], zoom_start=8) else: my_map = Map(location=[0, 0], zoom_start=2) mc = MarkerCluster() coords = [] # For each location convert address to coordinates, create popup and marker, # add to marker cluster for i in range(0, len(result), 1): popup_content = f"{result[i][0]} <br> " \ f"<a href={result[i][1]} > See Post" p = Popup(popup_content, max_width=400) mk = Marker([result[i][2], result[i][3]], p) mc.add_child(mk) lat_lon = (result[i][2], result[i][3]) coords.append(lat_lon) # Add Polyline with coords if self.handle == "4x4theboiz": polyline = PolyLine(coords, color="red", weight=2, opacity=0.7) polyline.add_to(my_map) elif self.handle == "tony_ontheroad": polyline = PolyLine(coords, color="red", weight=2, opacity=0.7) polyline.add_to(my_map) else: pass # Add Marker Cluster with mc my_map.add_child(mc) # Save the Map Instance Into a HTML file map_name = f"templates/map_{self.handle}.html" my_map.save(map_name)
def add_clusters(folium_map: folium.Map) -> None: ''' annotate_map: add clustered fatal crash markers to map Parameters: folium_map: map to which markers are to be added as Layer Returns: None Side Effects: Adds markers to input map as a Layer ''' global fatal lat = list(fatal['Crash_Latitude_GDA94']) lng = list(fatal['Crash_Longitude_GDA94']) dead_count = list(fatal['Count_Casualty_Fatality']) crash_nature = list(fatal['Crash_Nature']) crash_type = list(fatal['Crash_Type']) FATAL_MARKER_SIZE = 10 FATAL_MARKER_FILL_OPACITY = 0.25 # create a marker cluster layer clusters = MarkerCluster(name='Clustered Markers', show=False, control=True) # for each fatal crash, add marker to layer # marker is translucent so zoom out will look ok # Note: crash_type not used in this version for marker_y, marker_x, marker_dc, marker_cn, marker_ct in zip( lat, lng, dead_count, crash_nature, crash_type ): circ_mkr = folium.CircleMarker( location=[marker_y, marker_x], radius=FATAL_MARKER_SIZE, color='red', fill=True, fill_color='red', fillOpacity=FATAL_MARKER_FILL_OPACITY, opacity=FATAL_MARKER_FILL_OPACITY, tooltip=f'{marker_dc} Dead', popup=marker_cn, ) circ_mkr.add_to(clusters) # end for # add clustered markers to map clusters.add_to(folium_map) return None
def mupLoader(mapElement, fname, color): # open csv file and read coln initLen = len(data) print(initLen, len(data)) markuster = MarkerCluster() for row in data.itertuples(): markuster.add_child(Marker( location=[row[5], row[6]], popup=row[1] )) mapElement.add_child(markuster)
def main(user_lst, friends_lst, num): map_html = folium.Map() marker_cluster = MarkerCluster().add_to(map_html) geolocator = ArcGIS(timeout=10) lst = [ "Name: ", "Location: ", "Description: ", "url: ", "Followers: ", "Friends: ", "Listed: ", "Created: ", "Favourites: ", "Posts: " ] # Adding User on map place = geolocator.geocode(user_lst[1]) if place == None: popup_message = '<img src="{}"/><br>'.format(user_lst[-1]) for i in range(len(user_lst) - 1): popup_message += "{}{}<br>".format(lst[i], user_lst[i]) marker_cluster.add_child( folium.Marker(location=[randint(-90, 90), randint(-180, 180)], popup=popup_message, icon=folium.Icon(color='green'))) else: popup_message = '<img src="{}"/><br>'.format(user_lst[-1]) for i in range(len(user_lst) - 1): popup_message += "{}{}<br>".format(lst[i], user_lst[i]) marker_cluster.add_child( folium.Marker(location=[place.latitude, place.longitude], popup=popup_message, icon=folium.Icon(color='green'))) # Adding friends on map for i in range(len(friends_lst)): place = geolocator.geocode(friends_lst[i][1]) if place == None: popup_message = '<img src="{}"/><br>'.format(friends_lst[i][-1]) for j in range(len(friends_lst[i]) - 1): popup_message += "{}{}<br>".format(lst[j], friends_lst[i][j]) marker_cluster.add_child( folium.Marker(location=[randint(-90, 90), randint(-180, 180)], popup=popup_message, icon=folium.Icon(color='red'))) else: popup_message = '<img src="{}"/><br>'.format(friends_lst[i][-1]) for j in range(len(friends_lst[i]) - 1): popup_message += "{}{}<br>".format(lst[j], friends_lst[i][j]) marker_cluster.add_child( folium.Marker(location=[place.latitude, place.longitude], popup=popup_message, icon=folium.Icon(color='red'))) map_html.save("templates/map_html.html")
def CreatePopupCluster(markerArr): marker_cluster = MarkerCluster( name='1000 clustered icons', overlay=True, control=True, icon_create_function=None ) [marker_cluster.add_child(marker) for marker in markerArr] return marker_cluster
def draw(self): """ Gera um mapa de cluster a partir das opções enviadas """ # http://localhost:5000/charts/cluster?from_viewconf=S&au=2927408&card_id=mapa_prev_estado_cluster&observatory=te&dimension=prevalencia&as_image=N chart_options = self.options.get('chart_options') # TODO - [REMOVE] Used just for debugging # options["headers"] = [ # {'text': 'nm_municipio', "value": 'nm_municipio'}, # {'text': 'te_rgt_agr_sum_vl_indicador', "value": 'te_rgt_agr_sum_vl_indicador'}, # {'text': 'te_rgt_api_calc_min_part', "value": 'te_rgt_api_calc_min_part'}, # {'text': 'te_rgt_api_calc_max_part', "value": 'te_rgt_api_calc_max_part'}, # { # 'text': 'te_rgt_api_calc_ln_norm_pos_part', # "value": 'te_rgt_api_calc_ln_norm_pos_part' # }, # {'text': 'te_res_agr_sum_vl_indicador', "value": 'te_res_agr_sum_vl_indicador'}, # {'text': 'te_res_api_calc_min_part', "value": 'te_res_api_calc_min_part'}, # {'text': 'te_res_api_calc_max_part', "value": 'te_res_api_calc_max_part'}, # { # 'text': 'te_res_api_calc_ln_norm_pos_part', # "value": 'te_rgt_api_calc_ln_norm_pos_part' # }, # {'text': 'te_nat_agr_sum_vl_indicador', "value": 'te_nat_agr_sum_vl_indicador'}, # {'text': 'te_nat_api_calc_min_part', "value": 'te_nat_api_calc_min_part'}, # {'text': 'te_nat_api_calc_max_part', "value": 'te_nat_api_calc_max_part'}, # { # 'text': 'te_nat_api_calc_ln_norm_pos_part', # "value": 'te_nat_api_calc_ln_norm_pos_part' # } # ] result = self.pre_draw(self.get_tooltip_data()) grouped = self.dataframe.groupby( chart_options.get('layer_id', 'cd_indicador')) show = True # Shows only the first layer for group_id, group in grouped: chart = MarkerCluster( locations=group[self.get_location_columns()].values.tolist(), name=ViewConfReader.get_layers_names( self.options.get('headers')).get(group_id), show=show, popups=group['tooltip'].tolist()) show = False chart.add_to(result) result = self.add_au_marker(result, self.options.get('au')) return self.post_adjustments(result)
def plot_all_data(self, data, loc_col, ctry_col, lat_col, lng_col, clr='blue', as_cluster=True): """ Create markers for all of the locational data points. :param data: filepath (.csv or .xlsx extension) or dataframe. :type data: str or DataFrame. :param loc_col: name of location column. :type loc_col: str. :param ctry_col: name of country column. :type ctry_col: str. :param lat_col: name of latitude column. :type lat_col: str. :param lng_col: name of longitude column. :type lng_col: str. :param clr: color of the markers. :type clr: str. :param as_cluster: indicate whether the markers will be saved in a cluster or not. :type as_cluster: bool. :return: all of the created markers. :rtype: list of folium.Marker if ``as_cluster=False`` or a folium.MarkerCluster if ``as_cluster=True``. """ df = read_data(data, {loc_col, ctry_col, lat_col, lng_col}) if as_cluster: markers = MarkerCluster() else: markers = [] for (index, row) in df.iterrows(): if pd.notnull(row[lat_col]) and pd.notnull(row[lng_col]): lat = row[lat_col] lng = row[lng_col] location = self.format_popup(row[loc_col], row[ctry_col]) marker = self.plot_point(lat=lat, lng=lng, desc='%s, %s - (%.2f, %.2f)' % (location[0], location[1], lat, lng), clr=clr) if as_cluster: marker.add_to(markers) else: markers.append(marker) return markers
def addTrackMarkers(m, df, cruise): mc = MarkerCluster(name=cruise, options={ 'spiderfyOnMaxZoom': 'False', 'disableClusteringAtZoom': '4' }) for i in range(len(df)): folium.CircleMarker(location=[df.lat[i], df.lon[i]], radius=(2), color='darkOrange', fill=True).add_to(mc) mc.add_to(m) return m
def gerar_mapa(request): ip = get('https://api.ipify.org').text response1 = DbIpCity.get(ip, api_key='free') #print(response1) m = folium.Map([response1.latitude, response1.longitude], tiles='cartodbpositron', zoom_start=5, prefer_canvas=True) # Minimapa minimap = plugins.MiniMap(toggle_display=True) m.add_child(minimap) # add full screen button to map plugins.Fullscreen(position='topright').add_to(m) # Declaring points of latitude and longitude #my_locations = [(response1.latitude, response1.longitude),(-25.45,-49.34),(-25.45,-49.34)] doc_ref = db.collection('Pegasus').document(u'Exame') docs = doc_ref.get() exp = docs.to_dict() print(exp['Geopoints'][0]) print(exp['Geopoints'][1]) my_locations = [(exp['Geopoints'][0], exp['Geopoints'][1])] marker_cluster = MarkerCluster(my_locations) marker_cluster.add_to(m) #HeatMap(df).add_to(m) m.save('lab/templates/lab/mapa.html') table_file = open('lab/templates/lab/mapa.html') map_lines = table_file.readlines() table_file.close() table_file = open('lab/templates/lab/mapa.html', 'w+') first_lines = [ "{% extends 'lab/base.html'%} \n", #"{% load static %} \n", "{% block content %} \n", "{% if user.is_authenticated %} \n" ] end_lines = ["\n{% endif %}\n", "{% endblock %}"] table_file.writelines(first_lines) table_file.writelines(map_lines) table_file.close() table_file = open('lab/templates/lab/mapa.html', 'a+') table_file.writelines(end_lines) table_file.close() return render(request, 'lab/mapa.html')
def map2(): adr = mergedTables.objects.all() qs_adr = adr df_of_query_result_adr = read_frame(qs_adr) newTable_adr = df_of_query_result_adr m = folium.Map(location=[48.8566, 2.3522], tiles="Stamen Toner", zoom_start=2) #cergy=['49.034955','2.069925'] #pau=['43.319568','-0.360571'] newTable_ent_adr = newTable_adr[['ENT_LAT', 'ENT_LON']] newTable_stu_adr = newTable_adr[['ADR_LAT', 'ADR_LON']] newTable_site_adr = newTable_adr[['SITE_LAT', 'SITE_LON']] newTable_ent_adr = newTable_ent_adr.dropna(axis=0, subset=['ENT_LAT', 'ENT_LON']) newTable_stu_adr = newTable_stu_adr.dropna(axis=0, subset=['ADR_LAT', 'ADR_LON']) newTable_site_adr = newTable_site_adr.dropna( axis=0, subset=['SITE_LAT', 'SITE_LON']) #newTable_ent_adr= [[row['ENT_LAT'],row['ENT_LON']] for index,row in newTable_ent_adr.iterrows() ] #newTable_stu_adr= [[row['ADR_LAT'],row['ADR_LON']] for index,row in newTable_stu_adr.iterrows() ] #HeatMap(cergy).add_to(m) HeatMap(newTable_stu_adr).add_to(m) mc = MarkerCluster() folium.CircleMarker( [49.034955, 2.069925], radius=20, popup='Cergy Campus', color='red', ).add_to(m) folium.CircleMarker( [43.319568, -0.360571], radius=20, popup='Pau Campus', color='red', ).add_to(m) for i in range(0, len(newTable_stu_adr)): #mc.add_child(folium.Marker([newTable_ent_adr.iloc[i]['ENT_LAT'],newTable_ent_adr.iloc[i]['ENT_LON']],icon=folium.Icon(icon='cloud'))).add_to(m) mc.add_child( folium.Marker([ newTable_ent_adr.iloc[i]['ENT_LAT'], newTable_ent_adr.iloc[i]['ENT_LON'] ])).add_to(m) #mc.add_child(folium.Marker([newTable_stu_adr.iloc[i]['ADR_LAT'],newTable_stu_adr.iloc[i]['ADR_LON']],icon=folium.Icon(color='red'))).add_to(m) #folium.Marker([newTable_site_adr.iloc[i]['SITE_LAT'],newTable_site_adr.iloc[i]['SITE_LON']],icon=folium.Icon(icon='green')).add_to(m) #m.add_children(plugins.HeatMap(newTable_adr_lo, radius=15)) m.save(os.path.join(BASE_DIR, 'DjangoWeb V1\Interface\\templates\map.html')) return None
def getMap(df): #Vancouver location Co-ordinates. VC_COORDINATES = (49.2827, -123.1207) crime_map = folium.Map(location=VC_COORDINATES, zoom_start=8) marker = MarkerCluster() # This add markers on blank map for i in df.itertuples(): marker.add_child(folium.Marker(location=[i.Latitude, i.Longitude], popup=i.TYPE)) crime_map.add_child(marker) crime_map.save('static/map.html') return crime_map