def test_rgb_dataarray_groupby_infer(self):
rgb = self.da_rgb_by_time.hvplot.rgb('x', 'y', bands='band')
self.assertEqual(
rgb[0],
RGB(([0, 1], [0, 1]) + tuple(self.da_rgb_by_time.values[0])))
self.assertEqual(
rgb[1],
RGB(([0, 1], [0, 1]) + tuple(self.da_rgb_by_time.values[1])))
def test_rgb_dataarray_groupby_explicit(self):
rgb = self.da_rgb_by_time.hvplot.rgb('x', 'y', groupby='time')
self.assertEqual(
rgb[0],
RGB(([0, 1], [0, 1]) + tuple(self.da_rgb_by_time.values[0])))
self.assertEqual(
rgb[1],
RGB(([0, 1], [0, 1]) + tuple(self.da_rgb_by_time.values[1])))
def test_rgb_selection_numeric(self):
img = RGB(([0, 1, 2], [0, 1, 2, 3], np.random.rand(4, 3, 3)))
expr, bbox, region = img._get_selection_expr_for_stream_value(
bounds=(0.5, 1.5, 2.1, 3.1))
self.assertEqual(bbox, {'x': (0.5, 2.1), 'y': (1.5, 3.1)})
self.assertEqual(
expr.apply(img, expanded=True, flat=False),
np.array([[False, False, False], [False, False, False],
[False, True, True], [False, True, True]]))
self.assertEqual(region, Rectangles([(0.5, 1.5, 2.1, 3.1)]) * Path([]))
def test_rgb_opacity(self):
rgb_data = np.random.rand(10, 10, 3)
rgb = RGB(rgb_data).opts(opacity=0.5)
fig_dict = plotly_renderer.get_plot_state(rgb)
# Check layout.image object
images = fig_dict['layout']['images']
self.assertEqual(len(images), 1)
image = images[0]
# Check location properties
self.assert_property_values(
image, {
'xref': 'x',
'yref': 'y',
'x': -0.5,
'y': 0.5,
'sizex': 1.0,
'sizey': 1.0,
'sizing': 'stretch',
'layer': 'above',
'opacity': 0.5,
})
# Check image itself
pil_img = self.rgb_element_to_pil_img(rgb_data)
expected_source = go.layout.Image(source=pil_img).source
self.assertEqual(image['source'], expected_source)
def test_construct_from_dict_with_alpha(self):
rgb = RGB({
'x': [1, 2, 3],
'y': [1, 2, 3],
('R', 'G', 'B', 'A'): self.rgb_array
})
self.assertEqual(len(rgb.vdims), 4)
def test_rgb_invert_yaxis(self):
rgb = RGB(np.random.rand(10, 10, 3)).opts(plot=dict(invert_yaxis=True))
plot = bokeh_renderer.get_plot(rgb)
y_range = plot.handles['y_range']
self.assertEqual(y_range.start, 0.5)
self.assertEqual(y_range.end, -0.5)
cdata = plot.handles['source'].data
self.assertEqual(cdata['x'], [-0.5])
self.assertEqual(cdata['y'], [0.5])
self.assertEqual(cdata['dh'], [-1.0])
self.assertEqual(cdata['dw'], [1.0])
def test_rgb_invert_xaxis_and_yaxis_and_axes(self):
rgb_data = np.random.rand(10, 10, 3)
rgb = RGB(rgb_data).opts(invert_xaxis=True,
invert_yaxis=True,
invert_axes=True)
fig_dict = plotly_renderer.get_plot_state(rgb)
x_range = fig_dict['layout']['xaxis']['range']
self.assertEqual(x_range[0], 0.5)
self.assertEqual(x_range[1], -0.5)
y_range = fig_dict['layout']['yaxis']['range']
self.assertEqual(y_range[0], 0.5)
self.assertEqual(y_range[1], -0.5)
# Check layout.image object
images = fig_dict['layout']['images']
self.assertEqual(len(images), 1)
image = images[0]
# Check location properties
self.assert_property_values(
image, {
'xref': 'x',
'yref': 'y',
'x': 0.5,
'y': -0.5,
'sizex': -1.0,
'sizey': -1.0,
'sizing': 'stretch',
'layer': 'above',
})
# Check image itself
pil_img = self.rgb_element_to_pil_img(rgb.data)
# Flip left-to-right and top-to-bottom since both x-axis and y-axis are inverted
pil_img = (pil_img.transpose(PIL.Image.ROTATE_270).transpose(
PIL.Image.FLIP_LEFT_RIGHT))
expected_source = go.layout.Image(source=pil_img).source
self.assertEqual(image['source'], expected_source)
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 init_data(self):
self.rgb = RGB((self.xs, self.ys, self.rgb_array))
def init_data(self):
self.rgb = RGB((self.xs, self.ys, self.rgb_array[:, :, 0],
self.rgb_array[:, :, 1], self.rgb_array[:, :, 2]))
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_construct_from_tuple_with_alpha(self):
rgb = RGB(([0, 1, 2], [0, 1, 2], self.rgb_array))
self.assertEqual(len(rgb.vdims), 4)
def test_construct_from_array_with_alpha(self):
rgb = RGB(self.rgb_array)
self.assertEqual(len(rgb.vdims), 4)
def test_rgb_dataset_explicit_z(self):
rgb = self.da_rgb.to_dataset(name='z').hvplot.rgb(z='z')
self.assertEqual(rgb,
RGB(([0, 1], [0, 1]) + tuple(self.da_rgb.values)))
def test_rgb_dataarray_explicit_args_and_kind(self):
rgb = self.da_rgb.hvplot.rgb('x', 'y')
self.assertEqual(rgb,
RGB(([0, 1], [0, 1]) + tuple(self.da_rgb.values)))
def test_rgb_dataarray_no_args(self):
rgb = self.da_rgb.hvplot()
self.assertEqual(rgb,
RGB(([0, 1], [0, 1]) + tuple(self.da_rgb.values)))
