def test_raster_layer(self):
tiles = StamenTerrain().redim.range(x=self.x_range,
y=self.y_range).opts(alpha=0.7,
min_zoom=3,
max_zoom=7)
fig_dict = plotly_renderer.get_plot_state(tiles)
# Check dummy trace
self.assertEqual(len(fig_dict["data"]), 1)
dummy_trace = fig_dict["data"][0]
self.assertEqual(dummy_trace["type"], "scattermapbox")
self.assertEqual(dummy_trace["lon"], [])
self.assertEqual(dummy_trace["lat"], [])
self.assertEqual(dummy_trace["showlegend"], False)
# Check mapbox subplot
subplot = fig_dict["layout"]["mapbox"]
self.assertEqual(subplot["style"], "white-bg")
self.assertEqual(subplot['center'], {
'lat': self.lat_center,
'lon': self.lon_center
})
# Check for raster layer
layers = fig_dict["layout"]["mapbox"].get("layers", [])
self.assertEqual(len(layers), 1)
layer = layers[0]
self.assertEqual(layer["source"][0].lower(), tiles.data.lower())
self.assertEqual(layer["opacity"], 0.7)
self.assertEqual(layer["sourcetype"], "raster")
self.assertEqual(layer["minzoom"], 3)
self.assertEqual(layer["maxzoom"], 7)
self.assertEqual(layer["sourceattribution"],
_ATTRIBUTIONS[('stamen', 'com/t')])
hv.extension('bokeh', logo=False)
usecols = [
'dropoff_x', 'dropoff_y', 'pickup_x', 'pickup_y', 'dropoff_hour',
'pickup_hour', 'passenger_count'
]
df = dd.read_parquet('../../data/nyc_taxi_wide.parq',
engine='fastparquet')[usecols].persist()
opts = dict(width=1000,
height=600,
xaxis=None,
yaxis=None,
bgcolor='black',
show_grid=False)
cmaps = ['fire', 'bgy', 'bgyw', 'bmy', 'gray', 'kbc']
tiles = StamenTerrain()
class NYCTaxiExplorer(param.Parameterized):
alpha = param.Magnitude(default=0.75,
doc="Alpha value for the map opacity")
cmap = param.ObjectSelector(cm['fire'], objects={c: cm[c] for c in cmaps})
hour = param.Range(default=(0, 24), bounds=(0, 24))
location = param.ObjectSelector(default='dropoff',
objects=['dropoff', 'pickup'])
@param.depends('location', 'hour')
def points(self):
points = hv.Points(df,
kdims=[self.location + '_x', self.location + '_y'],
vdims=['dropoff_hour'])
def test_overlay(self):
# Base layer is mapbox vector layer
tiles = Tiles("").opts(mapboxstyle="dark", accesstoken="token-str")
# Raster tile layer
stamen_raster = StamenTerrain().opts(alpha=0.7)
# RGB layer
rgb_data = np.random.rand(10, 10, 3)
rgb = RGB(rgb_data,
bounds=(self.x_range[0], self.y_range[0], self.x_range[1],
self.y_range[1])).opts(opacity=0.5)
# Points layer
points = Points([(0, 0), (self.x_range[1], self.y_range[1])
]).opts(show_legend=True)
# Bounds
bounds = Bounds((self.x_range[0], self.y_range[0], 0, 0))
# Overlay
overlay = (tiles * stamen_raster * rgb * points * bounds).redim.range(
x=self.x_range, y=self.y_range)
# Render to plotly figure dictionary
fig_dict = plotly_renderer.get_plot_state(overlay)
# Check number of traces and layers
traces = fig_dict["data"]
subplot = fig_dict["layout"]["mapbox"]
layers = subplot["layers"]
self.assertEqual(len(traces), 5)
self.assertEqual(len(layers), 2)
# Check vector layer
dummy_trace = traces[0]
self.assertEqual(dummy_trace["type"], "scattermapbox")
self.assertEqual(dummy_trace["lon"], [])
self.assertEqual(dummy_trace["lat"], [])
self.assertFalse(dummy_trace["showlegend"])
self.assertEqual(subplot["style"], "dark")
self.assertEqual(subplot["accesstoken"], "token-str")
self.assertEqual(subplot['center'], {
'lat': self.lat_center,
'lon': self.lon_center
})
# Check raster layer
dummy_trace = traces[1]
raster_layer = layers[0]
self.assertEqual(dummy_trace["type"], "scattermapbox")
self.assertEqual(dummy_trace["lon"], [])
self.assertEqual(dummy_trace["lat"], [])
self.assertFalse(dummy_trace["showlegend"])
# Check raster_layer
self.assertEqual(raster_layer["below"], "traces")
self.assertEqual(raster_layer["opacity"], 0.7)
self.assertEqual(raster_layer["sourcetype"], "raster")
self.assertEqual(raster_layer["source"][0].lower(),
stamen_raster.data.lower())
# Check RGB layer
dummy_trace = traces[2]
rgb_layer = layers[1]
self.assertEqual(dummy_trace["type"], "scattermapbox")
self.assertEqual(dummy_trace["lon"], [None])
self.assertEqual(dummy_trace["lat"], [None])
self.assertFalse(dummy_trace["showlegend"])
# Check rgb_layer
self.assertEqual(rgb_layer["below"], "traces")
self.assertEqual(rgb_layer["opacity"], 0.5)
self.assertEqual(rgb_layer["sourcetype"], "image")
self.assertTrue(
rgb_layer["source"].startswith("data:image/png;base64,iVBOR"))
self.assertEqual(rgb_layer["coordinates"],
[[self.lon_range[0], self.lat_range[1]],
[self.lon_range[1], self.lat_range[1]],
[self.lon_range[1], self.lat_range[0]],
[self.lon_range[0], self.lat_range[0]]])
# Check Points layer
points_trace = traces[3]
self.assertEqual(points_trace["type"], "scattermapbox")
self.assertEqual(points_trace["lon"], np.array([0, self.lon_range[1]]))
self.assertEqual(points_trace["lat"], np.array([0, self.lat_range[1]]))
self.assertEqual(points_trace["mode"], "markers")
self.assertTrue(points_trace.get("showlegend", True))
# Check Bounds layer
bounds_trace = traces[4]
self.assertEqual(bounds_trace["type"], "scattermapbox")
self.assertEqual(
bounds_trace["lon"],
np.array([
self.lon_range[0], self.lon_range[0], 0, 0, self.lon_range[0]
]))
self.assertEqual(
bounds_trace["lat"],
np.array([
self.lat_range[0], 0, 0, self.lat_range[0], self.lat_range[0]
]))
self.assertEqual(bounds_trace["mode"], "lines")
self.assertTrue(points_trace["showlegend"], False)
# No xaxis/yaxis
self.assertNotIn("xaxis", fig_dict["layout"])
self.assertNotIn("yaxis", fig_dict["layout"])
class MedNumApp(param.Parameterized):
localisation = param.String(
default="Toulouse", label=""
) # default=["Toulouse"], objects=list(ifrag_cont_df_merged.nom_com.unique()), label='', doc="A string")
score = param.Range(
default=(0, 250),
bounds=(0, 250),
) # , name="Score")
interfaces_num = param.ListSelector(label="")
infos_num = param.ListSelector(label="")
comp_admin = param.ListSelector(label="")
comp_usage_num = param.ListSelector(label="")
point_ref = param.Selector(
objects=["Pays", "Région", "Département", "Intercommune", "Commune"],
label="Point de référence",
)
donnees_infra = param.Action(lambda x: x,
doc="""Données Infra-Communales""",
precedence=0.7)
export_data = param.Action(
lambda x: x.timestamps.append(dt.datetime.utcnow()),
doc="""Exporter les résultats""",
precedence=0.7,
)
edit_report = param.Action(
lambda x: x.timestamps.append(dt.datetime.utcnow()),
doc="""Editer un rapport""",
precedence=0.7,
)
tiles = StamenTerrain()
def __init__(self, **params):
super(MedNumApp, self).__init__(**params)
self.param.interfaces_num.objects = OPTIONS_INT_NUM
self.param.infos_num.objects = OPTIONS_X_INFOS
self.param.comp_admin.objects = OPTIONS_X_COMP_ADMIN
self.param.comp_usage_num.objects = OPTIONS_X_COMP_USAGE
indic_w_g_value_1 = {
"name":
"indic1_1",
"indicators": [
dict(name="accès", main=True, value=85, max_value=100),
dict(name="information", value=118),
# dict(name="indic3", value=168),
dict(name="Interfaces", value=53),
],
}
indic_w_g_value_2 = {
"indicators": [
dict(name="Compétences", main=True, value=135, max_value=180),
dict(name="indic3_2", value=115),
dict(name="indic4", value=155),
]
}
self.indicator_w_gauge_1 = IndicatorsWithGauge(**indic_w_g_value_1)
self.indicator_w_gauge_2 = IndicatorsWithGauge(**indic_w_g_value_2)
self.indicator_glob_stats = self.glob_stats()
def lat_widgets(self):
score_panel = pn.Column("# Score", self.param.score)
point_ref_panel = pn.Column(
"# Point de reference",
pn.Param(
self.param.point_ref,
widgets={
"point_ref": pn.widgets.RadioBoxGroup,
},
),
)
export_panel = pn.Column("# Aller plus loin", self.param.export_data,
self.param.edit_report)
localisation_panel = pn.Column("# Localisation",
self.param.localisation)
spec_interfaces = {
"interfaces_num": pn.widgets.TreeViewCheckBox,
"infos_num": pn.widgets.TreeViewCheckBox,
"comp_admin": pn.widgets.TreeViewCheckBox,
"comp_usage_num": pn.widgets.TreeViewCheckBox,
}
g_params = [
pn.Param(self.param[p], widgets={p: w})
for p, w in spec_interfaces.items()
]
pn.Column(*g_params)
indicateurs = pn.Column("# Indicateurs", *g_params)
ordered_panel = pn.Column(
localisation_panel,
score_panel,
indicateurs,
point_ref_panel,
export_panel,
width=400,
)
return ordered_panel
def link_ctrl_params_to_indic_params(self):
try:
return self.indicator_w_gauge.view
except:
return ""
@pn.depends('score', watch=True)
def glob_stats(self):
label = "Score Global"
score_min, score_max = self.score
HTML = """
<h1>{loc}</h1>
<b>{score_name}</b> | {score_min}->{score_max}<br>
<b>{pop_name}</b> | {population}
""".format(loc=self.localisation,
score_name=label,
score_min=score_min,
score_max=score_max,
pop_name="Population",
population="Beaucoup !!")
return pn.pane.HTML(HTML)
def top_panel(self):
try:
return pn.Row(self.indicator_glob_stats,
self.indicator_w_gauge_1.view,
self.indicator_w_gauge_2.view,
css_classes=["top-custom"],
height=120)
except:
return ""
@param.depends("localisation") # , interfaces_num)
def plot(self):
commune_plot = gv.Polygons(
ifrag_cont_df_merged[ifrag_cont_df_merged.nom_com ==
self.localisation],
vdims=vdims,
)
return self.tiles * commune_plot.opts(
color=indice, width=600, height=600, fill_alpha=0.5)
def view(self):
self.view = pn.Row(
self.lat_widgets(),
pn.Spacer(width=10),
pn.Column(self.top_panel, pn.Spacer(height=80), self.plot),
)
def panel(self):
return self.lat_widgets()