def print_geojson(geojson, limit=100):
center = None
j = json.load(StringIO(geojson))
layer_group = LayerGroup()
features = j['features']
if limit is not None:
features = features[0:limit]
for f in features:
location = (f['geometry']['coordinates'][1],
f['geometry']['coordinates'][0])
marker = Marker(location=location)
marker.popup = HTML(str(f['properties']))
layer_group.add_layer(marker)
if not center:
center = location
if not center:
center = (0, 0)
m = Map(layers=(basemap_to_tiles(basemaps.OpenStreetMap.Mapnik), ),
center=center,
zoom=8)
m.add_layer(layer_group)
return m
def prepare_map(dc, m):
dc.rectangle = {'shapeOptions': {'color': '#FF0000'}}
dc.marker = {
"shapeOptions": {
"fillColor": "#fca45d",
"color": "#fca45d",
"fillOpacity": 1.0
}
}
dc.polyline = {}
dc.polygon = {}
dc.circlemarker = {}
# Create a group of layers and add it to the Map
group = LayerGroup()
m.add_layer(group)
# given Africa: N: 38.25, S: -36.25, E: 53.25, W: -19.25
africa = GeoJSON(data={
'type': 'Feature',
'properties': {
'name': "Africa",
'style': {
'color': '#0000FF',
'clickable': True
}
},
'geometry': {
'type': 'Polygon',
'coordinates': [[[-19, 38], [53, 38], [53, -36], [-19, -36]]]
}
},
hover_style={'fillColor': '03449e'})
group.add_layer(africa)
# given Colombia: N: 13.75, S: -5.25, E: -62.75, W: -83.25
colombia = GeoJSON(data={
'type': 'Feature',
'properties': {
'name': "Colombia",
'style': {
'color': '#0000FF',
'clickable': True
}
},
'geometry': {
'type': 'Polygon',
'coordinates': [[[-83, 14], [-63, 14], [-63, -5], [-83, -5]]]
}
},
hover_style={'fillColor': '03449e'})
group.add_layer(colombia)
class App():
""" """
settings = {"enabled_grid": "B"}
def __init__(self, session=None):
self.session = session
self.use_grid = self.settings["enabled_grid"]
# generate map grid polygon layers
self.grid_layers = LayerGroup()
self.grid_dict = {}
for feat in above_grid["features"]:
level = feat["properties"]["grid_level"]
if level == self.use_grid:
Cell_object = Cell(feat)
#Cell_object.layer.on_click()
grid_id = Cell_object.id
self.grid_dict[grid_id] = Cell_object
self.grid_layers.add_layer(self.grid_dict[grid_id].layer)
# make an attribute that will hold selected layer
self.selected_layer = LayerGroup()
self.map = Map(layers=(
esri,
self.grid_layers,
self.selected_layer,
),
center=(65, -100),
zoom=3,
width="auto",
height="auto",
scroll_wheel_zoom=True)
# map draw controls
self.draw_control = DrawControl()
self.draw_control.polyline = {}
self.draw_control.circle = {}
self.draw_control.circlemarker = {}
self.draw_control.remove = False
self.draw_control.edit = False
self.draw_control.polygon = {**draw_style}
self.draw_control.rectangle = {**draw_style}
self.draw_control.on_draw(self.update_selected_cells)
self.map.add_control(self.draw_control)
# output display
self.output = Output(layout=Layout(width="auto", height="auto"))
# make the widget layout
self.ui = VBox(
[
#header,
#HBox([instruct, geojson_text]),
self.map,
self.output
],
layout=Layout(width="auto"))
# display ui
display(self.ui)
def update_selected_cells(self, *args, **kwargs):
""" """
# clear all draw and selection layers
self.draw_control.clear()
# --------------------------------------------------------------------
# update active cells and make a big merged polgyon for selection
# make shapely geom from geojson
drawn_json = kwargs["geo_json"]
shapely_geom = shape(drawn_json["geometry"])
cells = self.grid_dict
# iterate over cells and collect intersecting cells
on = []
for id, cell in cells.items():
if shapely_geom.intersects(cell.shape):
on.append(cell.shape)
# this is blatant abuse of try/except; fix it
try:
# get the union of all of the cells that are toggled on
union = cascaded_union(on)
centroid = union.centroid
# make layer that represents selected cells and add to selected_layer
self.selected_layer.clear_layers()
x, y = union.exterior.coords.xy
self.selected_layer.add_layer(Polygon(locations=list(zip(y, x))))
self.map.center = (centroid.y, centroid.x)
# --------------------------------------------------------------
# find all CMR collections that intersect with merged cells geom
selected = []
for index, collection in above_results_df.iterrows():
box = collection.boxes
shapely_box = CMR_box_to_Shapely_box(box[0])
# intersect: use shapely_geom if strictly using drawn poly
intersect_bool = shapely_box.intersects(union)
if intersect_bool:
selected.append(index)
self.coll = above_results_df.iloc[selected]
self.tab = qgrid.show_grid(
self.coll[["dataset_id", "time_start", "time_end", "boxes"]],
grid_options={
'forceFitColumns': False,
'minColumnWidth': "0",
'maxColumnWidth': "400"
},
show_toolbar=False)
self.output.clear_output()
with self.output:
display(self.tab)
#display(self.coll[[
# "dataset_id", "time_start", "time_end", "boxes"]])
except:
pass
def create_layer(geo_table,
name,
label_col=None,
secondary_label_col=None,
layer_type=None,
inverse=False,
**kwargs):
if 'color' in kwargs:
color = kwargs['color']
else:
color = 'orange'
output = LayerGroup(name=name)
geo_table = clean_table(geo_table)
if 'filter_on' in kwargs.keys():
filter_col = kwargs['filter_on']
if inverse:
geo_table = geo_table[geo_table[filter_col].isna()]
else:
geo_table = geo_table[~geo_table[filter_col].isna()]
if layer_type is None:
raise (ValueError('must provide a type of layer to make with table!'))
for _, row in geo_table.iterrows():
if layer_type == 'polygon':
y = list(row.geometry.exterior.coords.xy[1])
x = list(row.geometry.exterior.coords.xy[0])
locations = [(y, x) for y, x in zip(y, x)]
temp_layer = Polygon(
locations=locations,
color=color,
fill_color=color,
opacity=0.8,
)
elif layer_type == 'marker':
temp_layer = CircleMarker(
location=(row.geometry.y, row.geometry.x),
color=color,
radius=5,
fill_color=color,
)
if label_col is not None:
if secondary_label_col is not None:
extra_labels = row[secondary_label_col]
if extra_labels is None:
extra_labels = ''
else:
extra_labels = extra_labels.split(',')
size = len(extra_labels)
if size > 6:
size = 6
extra_labels = extra_labels[:size]
extra_labels.append('truncated')
extra_labels = '\n'.join(extra_labels[:size])
else:
extra_labels = ''
message = HTML()
message.value = extra_labels
message.description = row[label_col]
temp_layer.popup = message
temp_layer.popup_max_width = 800
output.add_layer(temp_layer)
geo_table.to_file(name + '.shp')
return output