def test_scatter_state(self):
# Precompute coordinates
xs = [3000000, 2000000, 1000000]
ys = [-3000000, -2000000, -1000000]
x_range = (-5000000, 4000000)
x_center = sum(x_range) / 2.0
y_range = (-3000000, 2000000)
y_center = sum(y_range) / 2.0
lon_centers, lat_centers = Tiles.easting_northing_to_lon_lat([x_center], [y_center])
lon_center, lat_center = lon_centers[0], lat_centers[0]
lons, lats = Tiles.easting_northing_to_lon_lat(xs, ys)
scatter = Tiles('') * Scatter((xs, ys)).redim.range(x=x_range, y=y_range)
state = self._get_plot_state(scatter)
self.assertEqual(state['data'][1]['type'], 'scattermapbox')
self.assertEqual(state['data'][1]['lon'], lons)
self.assertEqual(state['data'][1]['lat'], lats)
self.assertEqual(state['data'][1]['mode'], 'markers')
self.assertEqual(
state['layout']['mapbox']['center'], {'lat': lat_center, 'lon': lon_center}
)
# There xaxis and yaxis should not be in the layout
self.assertFalse('xaxis' in state['layout'])
self.assertFalse('yaxis' in state['layout'])
def test_single_box(self):
box = Tiles("") * Box(0, 0,
(1000000, 2000000)).redim.range(x=self.x_range,
y=self.y_range)
x_box_range = [-500000, 500000]
y_box_range = [-1000000, 1000000]
lon_box_range, lat_box_range = Tiles.easting_northing_to_lon_lat(
x_box_range, y_box_range)
state = self._get_plot_state(box)
self.assertEqual(state["data"][1]["type"], "scattermapbox")
self.assertEqual(state["data"][1]["mode"], "lines")
self.assertEqual(state["data"][1]["showlegend"], False)
self.assertEqual(state["data"][1]["line"]["color"],
default_shape_color)
self.assertEqual(state["data"][1]["lon"],
np.array([lon_box_range[i] for i in (0, 0, 1, 1, 0)]))
self.assertEqual(state["data"][1]["lat"],
np.array([lat_box_range[i] for i in (0, 1, 1, 0, 0)]))
self.assertEqual(state['layout']['mapbox']['center'], {
'lat': self.lat_center,
'lon': self.lon_center
})
def test_curve_interpolation(self):
from holoviews.operation import interpolate_curve
interp_xs = np.array([0., 0.5, 0.5, 1.5, 1.5, 2.])
interp_curve = interpolate_curve(Curve(self.ys), interpolation='steps-mid')
interp_ys = interp_curve.dimension_values("y")
interp_lons, interp_lats = Tiles.easting_northing_to_lon_lat(interp_xs, interp_ys)
curve = Tiles("") * Curve(self.ys).options(interpolation='steps-mid')
state = self._get_plot_state(curve)
self.assertEqual(state['data'][1]['lat'], interp_lats)
self.assertEqual(state['data'][1]['lon'], interp_lons)
def test_labels_yoffset(self):
offset = 20000
labels = Tiles("") * Labels([(self.xs[0], self.ys[0], 'A'),
(self.xs[1], self.ys[1], 'B'),
(self.xs[2], self.ys[2], 'C')
]).options(yoffset=offset)
state = self._get_plot_state(labels)
lons, lats = Tiles.easting_northing_to_lon_lat(
self.xs,
np.array(self.ys) + offset)
self.assertEqual(state['data'][1]['lon'], lons)
self.assertEqual(state['data'][1]['lat'], lats)
def setUp(self):
super().setUp()
# Precompute coordinates
self.xs = [3000000, 2000000, 1000000]
self.ys = [-3000000, -2000000, -1000000]
self.x_range = (-5000000, 4000000)
self.x_center = sum(self.x_range) / 2.0
self.y_range = (-3000000, 2000000)
self.y_center = sum(self.y_range) / 2.0
self.lon_centers, self.lat_centers = Tiles.easting_northing_to_lon_lat(
[self.x_center], [self.y_center]
)
self.lon_center, self.lat_center = self.lon_centers[0], self.lat_centers[0]
self.lons, self.lats = Tiles.easting_northing_to_lon_lat(self.xs, self.ys)
def test_scatter_markers(self):
scatter = Tiles('') * Scatter([
(0, 1, 'square'), (1, 2, 'circle'), (2, 3, 'triangle-up')
], vdims=['y', 'marker']).options(marker='marker')
state = self._get_plot_state(scatter)
self.assertEqual(state['data'][1]['marker']['symbol'],
np.array(['square', 'circle', 'triangle-up']))
def test_scatter_colors(self):
scatter = Tiles('') * Scatter([
(0, 1, 'red'), (1, 2, 'green'), (2, 3, 'blue')
], vdims=['y', 'color']).options(color='color')
state = self._get_plot_state(scatter)
self.assertEqual(state['data'][1]['marker']['color'],
np.array(['red', 'green', 'blue']))
def test_segments_simple(self):
rectangles = Tiles("") * Segments([
(0, 0, self.x_range[1], self.y_range[1]),
(self.x_range[0], self.y_range[0], 0, 0),
]).redim.range(x=self.x_range, y=self.y_range)
state = self._get_plot_state(rectangles)
self.assertEqual(state["data"][1]["type"], "scattermapbox")
self.assertEqual(state["data"][1]["mode"], "lines")
self.assertEqual(state["data"][1]["showlegend"], False)
self.assertEqual(state["data"][1]["line"]["color"],
default_shape_color)
self.assertEqual(
state["data"][1]["lon"],
np.array(
[0, self.lon_range[1], np.nan, self.lon_range[0], 0, np.nan]))
self.assertEqual(
state["data"][1]["lat"],
np.array(
[0, self.lat_range[1], np.nan, self.lat_range[0], 0, np.nan]))
self.assertEqual(state['layout']['mapbox']['center'], {
'lat': self.lat_center,
'lon': self.lon_center
})
def test_bounds_layout(self):
bounds1 = Bounds((0, 0, 1, 1))
bounds2 = Bounds((0, 0, 2, 2))
bounds3 = Bounds((0, 0, 3, 3))
bounds4 = Bounds((0, 0, 4, 4))
layout = (Tiles("") * bounds1 + Tiles("") * bounds2 +
Tiles("") * bounds3 + Tiles("") * bounds4).cols(2)
state = self._get_plot_state(layout)
self.assertEqual(state['data'][1]["subplot"], "mapbox")
self.assertEqual(state['data'][3]["subplot"], "mapbox2")
self.assertEqual(state['data'][5]["subplot"], "mapbox3")
self.assertEqual(state['data'][7]["subplot"], "mapbox4")
self.assertNotIn("xaxis", state['layout'])
self.assertNotIn("yaxis", state['layout'])
def test_mapbox_tiles_defaults(self):
tiles = Tiles("").redim.range(x=self.x_range, y=self.y_range)
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 that xaxis and yaxis entries are not created
self.assertNotIn("xaxis", fig_dict["layout"])
self.assertNotIn("yaxis", fig_dict["layout"])
# Check no layers are introduced when an empty tile server string is
# passed
layers = fig_dict["layout"]["mapbox"].get("layers", [])
self.assertEqual(len(layers), 0)
def test_scatter_selectedpoints(self):
scatter = Tiles('') * Scatter([(
0,
1,
), (1, 2), (2, 3)]).options(selectedpoints=[1, 2])
state = self._get_plot_state(scatter)
self.assertEqual(state['data'][1]['selectedpoints'], [1, 2])
def test_scatter_color_mapped(self):
scatter = Tiles('') * Scatter([3, 2, 1]).options(color='x')
state = self._get_plot_state(scatter)
self.assertEqual(state['data'][1]['marker']['color'],
np.array([0, 1, 2]))
self.assertEqual(state['data'][1]['marker']['cmin'], 0)
self.assertEqual(state['data'][1]['marker']['cmax'], 2)
def test_labels_inverted(self):
labels = Tiles("") * Labels([(0, 3, 0), (1, 2, 1),
(2, 1, 1)]).options(invert_axes=True)
with self.assertRaises(ValueError) as e:
self._get_plot_state(labels)
self.assertIn("invert_axes", str(e.exception))
def test_xyzservices_tileprovider(self):
xyzservices = pytest.importorskip("xyzservices")
osm = xyzservices.providers.OpenStreetMap.Mapnik
tiles = Tiles(osm)
plot = bokeh_renderer.get_plot(tiles)
glyph = plot.handles["glyph"]
assert glyph.attribution == osm.html_attribution
assert glyph.url == osm.build_url(scale_factor="@2x")
assert glyph.max_zoom == osm.max_zoom
def test_curve_state(self):
curve = Tiles("") * Curve(
(self.xs, self.ys)).redim.range(x=self.x_range, y=self.y_range)
state = self._get_plot_state(curve)
self.assertEqual(state['data'][1]['lon'], self.lons)
self.assertEqual(state['data'][1]['lat'], self.lats)
self.assertEqual(state['data'][1]['mode'], 'lines')
self.assertEqual(state['layout']['mapbox']['center'], {
'lat': self.lat_center,
'lon': self.lon_center
})
def test_labels_state(self):
labels = Tiles("") * Labels([
(self.xs[0], self.ys[0], 'A'), (self.xs[1], self.ys[1], 'B'),
(self.xs[2], self.ys[2], 'C')
]).redim.range(x=self.x_range, y=self.y_range)
state = self._get_plot_state(labels)
self.assertEqual(state['data'][1]['lon'], self.lons)
self.assertEqual(state['data'][1]['lat'], self.lats)
self.assertEqual(state['data'][1]['text'], ['A', 'B', 'C'])
self.assertEqual(state['data'][1]['mode'], 'text')
self.assertEqual(state['layout']['mapbox']['center'], {
'lat': self.lat_center,
'lon': self.lon_center
})
def test_styled_mapbox_tiles(self):
tiles = Tiles("").opts(mapboxstyle="dark",
accesstoken="token-str").redim.range(
x=self.x_range, y=self.y_range)
fig_dict = plotly_renderer.get_plot_state(tiles)
# Check mapbox subplot
subplot = fig_dict["layout"]["mapbox"]
self.assertEqual(subplot["style"], "dark")
self.assertEqual(subplot["accesstoken"], "token-str")
self.assertEqual(subplot['center'], {
'lat': self.lat_center,
'lon': self.lon_center
})
def test_xyzservices_tileprovider(self):
xyzservices = pytest.importorskip("xyzservices")
osm = xyzservices.providers.OpenStreetMap.Mapnik
tiles = Tiles(osm, name="xyzservices").redim.range(x=self.x_range,
y=self.y_range)
fig_dict = plotly_renderer.get_plot_state(tiles)
# Check mapbox subplot
layers = fig_dict["layout"]["mapbox"].get("layers", [])
self.assertEqual(len(layers), 1)
layer = layers[0]
self.assertEqual(layer["source"][0].lower(),
osm.build_url(scale_factor="@2x"))
self.assertEqual(layer["maxzoom"], osm.max_zoom)
self.assertEqual(layer["sourceattribution"], osm.html_attribution)
def test_single_bounds(self):
bounds = Tiles("") * Bounds(
(self.x_range[0], self.y_range[0], self.x_range[1],
self.y_range[1])).redim.range(x=self.x_range, y=self.y_range)
state = self._get_plot_state(bounds)
self.assertEqual(state["data"][1]["type"], "scattermapbox")
self.assertEqual(state["data"][1]["mode"], "lines")
self.assertEqual(
state["data"][1]["lon"],
np.array([self.lon_range[i] for i in (0, 0, 1, 1, 0)]))
self.assertEqual(
state["data"][1]["lat"],
np.array([self.lat_range[i] for i in (0, 1, 1, 0, 0)]))
self.assertEqual(state["data"][1]["showlegend"], False)
self.assertEqual(state["data"][1]["line"]["color"],
default_shape_color)
self.assertEqual(state['layout']['mapbox']['center'], {
'lat': self.lat_center,
'lon': self.lon_center
})
def test_rgb(self):
rgb_data = np.random.rand(10, 10, 3)
rgb = Tiles("") * RGB(
rgb_data,
bounds=(self.x_range[0], self.y_range[0], self.x_range[1],
self.y_range[1])).opts(opacity=0.5).redim.range(
x=self.x_range, y=self.y_range)
fig_dict = plotly_renderer.get_plot_state(rgb)
# Check dummy trace
self.assertEqual(fig_dict["data"][1]["type"], "scattermapbox")
self.assertEqual(fig_dict["data"][1]["lon"], [None])
self.assertEqual(fig_dict["data"][1]["lat"], [None])
self.assertEqual(fig_dict["data"][1]["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 rgb layer
layers = fig_dict["layout"]["mapbox"]["layers"]
self.assertEqual(len(layers), 1)
rgb_layer = layers[0]
self.assertEqual(rgb_layer["below"], "traces")
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]]])
self.assertTrue(
rgb_layer["source"].startswith("data:image/png;base64,iVBOR"))
self.assertEqual(rgb_layer["opacity"], 0.5)
self.assertEqual(rgb_layer["sourcetype"], "image")
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"])
def test_curve_inverted(self):
curve = Tiles("") * Curve([1, 2, 3]).options(invert_axes=True)
with self.assertRaises(ValueError) as e:
self._get_plot_state(curve)
self.assertIn("invert_axes", str(e.exception))
def test_visible(self):
element = Tiles("") * Curve([1, 2, 3]).options(visible=False)
state = self._get_plot_state(element)
self.assertEqual(state['data'][1]['visible'], False)
def test_curve_line_width(self):
curve = Tiles("") * Curve([1, 2, 3]).options(line_width=5)
state = self._get_plot_state(curve)
self.assertEqual(state['data'][1]['line']['width'], 5)
def test_curve_dash(self):
curve = Tiles("") * Curve([1, 2, 3]).options(dash='dash')
with self.assertRaises(ValueError) as e:
self._get_plot_state(curve)
self.assertIn("dash", str(e.exception))
def test_curve_color_mapping_error(self):
curve = Tiles("") * Curve([1, 2, 3]).options(color='x')
with self.assertRaises(ValueError):
self._get_plot_state(curve)
def test_curve_color(self):
curve = Tiles("") * Curve([1, 2, 3]).options(color='red')
state = self._get_plot_state(curve)
self.assertEqual(state['data'][1]['line']['color'], 'red')
def test_visible(self):
element = Tiles('') * Scatter([3, 2, 1]).options(visible=False)
state = self._get_plot_state(element)
self.assertEqual(state['data'][1]['visible'], False)
def test_labels_size(self):
labels = Tiles("") * Labels([(0, 3, 0), (0, 2, 1),
(0, 1, 1)]).options(size=23)
state = self._get_plot_state(labels)
self.assertEqual(state['data'][1]['textfont']['size'], 23)
def test_visible(self):
element = Tiles("") * Labels([(0, 3, 0), (1, 2, 1),
(2, 1, 1)]).options(visible=False)
state = self._get_plot_state(element)
self.assertEqual(state['data'][1]['visible'], False)
