Add export tools for bqplot viewers

.github/workflows/ci_workflows.yml

@@ -52,7 +52,7 @@ jobs:
     uses: OpenAstronomy/github-actions-workflows/.github/workflows/publish_pure_python.yml@v1
     with:
       libraries: '^libxcb.*-dev libxkbcommon-x11-dev libgl1-mesa-glx xvfb'
-      test_extras: 'test,qt'
+      test_extras: 'test,qt,jupyter'
       test_command: Xvfb :99 -screen 0 1024x768x24 > /dev/null 2>&1 & sleep 3; DISPLAY=:99.0 pytest --pyargs glue_plotly
     secrets:
       pypi_token: ${{ secrets.pypi_token }}

glue_plotly/__init__.py

@@ -7,14 +7,27 @@
 except DistributionNotFound:
     pass
 
-PLOTLY_LOGO = os.path.abspath(os.path.join(os.path.dirname(__file__), 'logo.png'))
+
+PLOTLY_LOGO = os.path.abspath(os.path.join(os.path.dirname(__file__), 'logo'))
 PLOTLY_ERROR_MESSAGE = "An error occurred during the export to Plotly:"
 
 
 def setup():
+    try:
+        setup_qt()
+    except ImportError:
+        pass
+
+    try:
+        setup_jupyter()
+    except ImportError:
+        pass
+
+
+def setup_qt():
 
     from . import common  # noqa
-    from . import html_exporters  # noqa
+    from .html_exporters import qt  # noqa
     from .web.qt import setup
     setup()
 
@@ -61,3 +74,16 @@
         pass
     else:
         VispyScatterViewer.subtools['save'] = VispyScatterViewer.subtools['save'] + ['save:plotly3d']
+
+
+def setup_jupyter():
+    from .html_exporters import bqplot  # noqa
+    from glue_jupyter.bqplot.histogram import BqplotHistogramView
+    from glue_jupyter.bqplot.image import BqplotImageView
+    from glue_jupyter.bqplot.profile import BqplotProfileView
+    from glue_jupyter.bqplot.scatter import BqplotScatterView
+
+    BqplotHistogramView.tools += ['save:bqplot_plotlyhist']
+    BqplotImageView.tools += ['save:bqplot_plotlyimage2d']
+    BqplotProfileView.tools += ['save:bqplot_plotlyprofile']
+    BqplotScatterView.tools += ['save:bqplot_plotly2d']

glue_plotly/common/common.py

@@ -3,7 +3,12 @@
 
 from glue.config import settings
 from glue.core import BaseData
-from glue_qt.viewers.common.data_viewer import DataViewer
+try:
+    from glue_qt.viewers.common.data_viewer import DataViewer
+    from glue_jupyter.bqplot.common import BqplotBaseView
+except ImportError:
+    DataViewer = type(None)
+    BqplotBaseView = type(None)
 
 from glue_plotly.utils import is_rgba_hex, opacity_value_string, rgba_hex_to_rgb_hex
 
@@ -14,6 +19,8 @@
     # TODO: Add implementation for bqplot viewers
     if isinstance(viewer, DataViewer):
         return viewer.figure.get_size_inches() * viewer.figure.dpi
+    elif isinstance(viewer, BqplotBaseView):
+        return 1200, 600  # TODO: What to do here?
     else:  # For now, this means a Plotly-based viewer
         return viewer.figure.layout.width, viewer.figure.layout.height
 

glue_plotly/common/histogram.py

@@ -16,8 +16,20 @@ def axis_from_mpl(viewer, ax, glue_ticks=True):
     return a
 
 
-def layout_config_from_mpl(viewer):
-    config = base_layout_config(viewer, barmode="overlay", bargap=0)
+def layout_config(viewer, **kwargs):
+    kwargs.setdefault("barmode", "overlay")
+    kwargs.setdefault("bargap", 0)
+    config = base_layout_config(viewer, **kwargs)
+    x_axis = base_rectilinear_axis(viewer.state, 'x')
+    y_axis = base_rectilinear_axis(viewer.state, 'y')
+    config.update(xaxis=x_axis, yaxis=y_axis)
+    return config
+
+
+def layout_config_from_mpl(viewer, **kwargs):
+    kwargs.setdefault("barmode", "overlay")
+    kwargs.setdefault("bargap", 0)
+    config = base_layout_config(viewer, **kwargs)
     x_axis = axis_from_mpl(viewer, 'x')
     y_axis = axis_from_mpl(viewer, 'y')
     config.update(xaxis=x_axis, yaxis=y_axis)
@@ -56,11 +68,9 @@ def traces_for_layer(viewer_state, layer_state, add_data_label=True):
             )
             traces.append(Bar(**hist_info))
     else:
-        width = edges[1] - edges[0]
         hist_info.update(
             x=x,
             y=y,
-            width=width,
             meta=bars_id
         )
         traces.append(Bar(**hist_info))

glue_plotly/common/image.py

@@ -7,6 +7,8 @@
 
 from glue.config import settings
 from glue.utils import ensure_numerical
+
+from glue_plotly.common.common import base_rectilinear_axis
 try:
     from glue.config import stretches
 except ImportError:
@@ -33,21 +35,21 @@
     if using_colormaps:
         return [256, 256, 256, 1]
     else:
-        img = viewer.axes._composite()
+        img = composite_array(viewer)()
         bg_color = [_ for _ in img[0][0]]
         for i in range(3):
             bg_color[i] *= 256
         return bg_color
 
 
-def layout_config_from_mpl(viewer):
+def layout_config(viewer):
     bg_color = background_color(viewer)
     return base_layout_config(viewer,
                               plot_bgcolor='rgba{0}'.format(tuple(bg_color)),
                               showlegend=True)
 
 
-def axes_data(viewer):
+def axes_data_from_mpl(viewer):
     axes_data = {}
 
     axes = viewer.axes
@@ -120,9 +122,25 @@
     return axes_data
 
 
-def shape(viewer):
-    xy_axes = sorted([viewer.state.x_att.axis, viewer.state.y_att.axis])
-    return [viewer.state.reference_data.shape[i] for i in xy_axes]
+def axes_data_from_bqplot(viewer):
+    return dict(
+        xaxis=base_rectilinear_axis(viewer.state, 'x'),
+        yaxis=base_rectilinear_axis(viewer.state, 'y')
+    )
+
+
+def shape(viewer_state):
+    xy_axes = sorted([viewer_state.x_att.axis, viewer_state.y_att.axis])
+    return [viewer_state.reference_data.shape[i] for i in xy_axes]
+
+
+def composite_array(viewer):
+    # Qt viewer
+    try:
+        return viewer.axes._composite
+    # bqplot
+    except AttributeError:
+        return viewer._composite
 
 
 def image_size_info(layer_state):
@@ -176,20 +194,19 @@
     return dict(scatter=scatter_layers, image=image_layers, image_subset=image_subset_layers)
 
 
-def full_view_transpose(viewer):
-    state = viewer.state
-    full_view, _agg_func, transpose = state.numpy_slice_aggregation_transpose
-    full_view[state.x_att.axis] = slice(None)
-    full_view[state.y_att.axis] = slice(None)
-    for i in range(state.reference_data.ndim):
+def full_view_transpose(viewer_state):
+    full_view, _agg_func, transpose = viewer_state.numpy_slice_aggregation_transpose
+    full_view[viewer_state.x_att.axis] = slice(None)
+    full_view[viewer_state.y_att.axis] = slice(None)
+    for i in range(viewer_state.reference_data.ndim):
         if isinstance(full_view[i], slice):
-            full_view[i] = slice_to_bound(full_view[i], state.reference_data.shape[i])
+            full_view[i] = slice_to_bound(full_view[i], viewer_state.reference_data.shape[i])
 
     return full_view, transpose
 
 
-def empty_secondary_layer(viewer, secondary_x, secondary_y):
-    bg = np.ones(shape(viewer))
+def empty_secondary_layer(viewer_state, secondary_x, secondary_y):
+    bg = np.ones(shape(viewer_state))
     secondary_info = dict(z=bg,
                           colorscale=[[0, 'rgb(0,0,0)'], [1, 'rgb(0,0,0)']],
                           hoverinfo='skip',
@@ -200,48 +217,44 @@
     return Heatmap(**secondary_info)
 
 
-def background_heatmap_layer(viewer):
+def background_heatmap_layer(viewer_state):
     """
     This function creates an all-white heatmap which we can use as the bottom layer
     when the viewer is using colormap, to match what we see in glue
     """
-    bg = np.ones(shape(viewer))
+    bg = np.ones(shape(viewer_state))
     bottom_color = (256, 256, 256)
     bottom_colorstring = 'rgb{0}'.format(bottom_color)
     bottom_info = dict(z=bg, hoverinfo='skip', opacity=1, showscale=False,
                        colorscale=[[0, bottom_colorstring], [1, bottom_colorstring]])
     return Heatmap(**bottom_info)
 
 
-def traces_for_pixel_subset_layer(viewer, layer):
-    state = layer.state
-    subset_state = layer.layer.subset_state
-    xmin, xmax = viewer.axes.get_xlim()
-    ymin, ymax = viewer.axes.get_ylim()
+def traces_for_pixel_subset_layer(viewer_state, layer_state):
+    subset_state = layer_state.layer.subset_state
 
     try:
-        x, y = subset_state.get_xy(layer.layer.data, viewer.state.x_att.axis, viewer.state.y_att.axis)
+        x, y = subset_state.get_xy(layer_state.layer.data, viewer_state.x_att.axis, viewer_state.y_att.axis)
         line_data = dict(
             mode="lines",
             marker=dict(
-                color=state.color
+                color=layer_state.color
             ),
-            opacity=state.alpha * 0.5,
-            name=state.layer.label,
+            opacity=layer_state.alpha * 0.5,
+            name=layer_state.layer.label,
             legendgroup=uuid4().hex
         )
 
-        x_line_data = {**line_data, 'x': [x, x], 'y': [ymin, ymax], 'showlegend': True}
-        y_line_data = {**line_data, 'x': [xmin, xmax], 'y': [y, y], 'showlegend': False}
+        x_line_data = {**line_data, 'x': [x, x], 'y': [viewer_state.y_min, viewer_state.y_max], 'showlegend': True}
+        y_line_data = {**line_data, 'x': [viewer_state.x_min, viewer_state.x_max], 'y': [y, y], 'showlegend': False}
         return [Scatter(**x_line_data), Scatter(**y_line_data)]
     except IncompatibleAttribute:
         return []
 
 
-def traces_for_nonpixel_subset_layer(viewer, layer, full_view, transpose):
-    layer_state = layer.state
-    subset_state = layer.layer.subset_state
-    ref_data = viewer.state.reference_data
+def traces_for_nonpixel_subset_layer(viewer_state, layer_state, full_view, transpose):
+    subset_state = layer_state.layer.subset_state
+    ref_data = viewer_state.reference_data
     color = fixed_color(layer_state)
     buffer = ref_data.compute_fixed_resolution_buffer(full_view, target_data=ref_data,
                                                       broadcast=False, subset_state=subset_state)
@@ -270,10 +283,7 @@
     return [Heatmap(**image_info)]
 
 
-def traces_for_scatter_layer(viewer, layer, hover_data=None, add_data_label=True):
-    viewer_state = viewer.state
-    layer_state = layer.state
-
+def traces_for_scatter_layer(viewer_state, layer_state, hover_data=None, add_data_label=True):
     x = layer_state.layer[viewer_state.x_att].copy()
     y = layer_state.layer[viewer_state.y_att].copy()
     mask, (x, y) = sanitize(x, y)
@@ -300,8 +310,8 @@
                                             hover_values[k]))
 
     name = layer_state.layer.label
-    if add_data_label and not isinstance(layer.layer, BaseData):
-        name += " ({0})".format(layer.layer.data.label)
+    if add_data_label and not isinstance(layer_state.layer, BaseData):
+        name += " ({0})".format(layer_state.layer.data.label)
     scatter_info = dict(mode='markers',
                         marker=marker,
                         x=x,
@@ -320,6 +330,8 @@
 
     interval = ManualInterval(layer_state.v_min, layer_state.v_max)
     constrast_bias = ContrastBiasStretch(layer_state.contrast, layer_state.bias)
+
+    # This works for either Qt or bqplot layers
     array = layer.get_image_data
     if callable(array):
         array = array(bounds=None)
@@ -348,7 +360,7 @@
 
 
 def single_color_trace(viewer):
-    img = viewer.axes._composite()
+    img = composite_array(viewer)()
     img[:, :, :3] *= 256
     image_info = dict(z=img,
                       opacity=1,
@@ -365,10 +377,10 @@
     has_nonpixel_subset = any(not isinstance(layer.layer.subset_state, PixelSubsetState)
                               for layer in layers['image_subset'])
     if has_nonpixel_subset:
-        full_view, transpose = full_view_transpose(viewer)
+        full_view, transpose = full_view_transpose(viewer.state)
 
     if using_colormaps:
-        traces.append(background_heatmap_layer(viewer))
+        traces.append(background_heatmap_layer(viewer.state))
         for layer in layers['image']:
             traces += traces_for_image_layer(layer)
     else:
@@ -377,16 +389,16 @@
     for layer in layers['image_subset']:
         subset_state = layer.layer.subset_state
         if isinstance(subset_state, PixelSubsetState):
-            traces += traces_for_pixel_subset_layer(viewer, layer)
+            traces += traces_for_pixel_subset_layer(viewer.state, layer.state)
         else:
-            traces += traces_for_nonpixel_subset_layer(viewer, layer, full_view, transpose)
+            traces += traces_for_nonpixel_subset_layer(viewer.state, layer.state, full_view, transpose)
 
     for layer in layers['scatter']:
-        traces += traces_for_scatter_layer(viewer, layer,
+        traces += traces_for_scatter_layer(viewer.state, layer.state,
                                            hover_data=hover_selections[layer.state.layer.label],
                                            add_data_label=add_data_label)
 
     if secondary_x or secondary_y:
-        traces.append(empty_secondary_layer(viewer, secondary_x, secondary_y))
+        traces.append(empty_secondary_layer(viewer.state, secondary_x, secondary_y))
 
     return traces

glue_plotly/common/profile.py

@@ -2,7 +2,7 @@
 from plotly.graph_objs import Scatter
 
 from glue_plotly.common import fixed_color
-from glue_plotly.common.histogram import axis_from_mpl, layout_config_from_mpl  # noqa
+from glue_plotly.common.histogram import axis_from_mpl, layout_config, layout_config_from_mpl  # noqa
 
 
 def traces_for_layer(viewer_state, layer_state, add_data_label=True):

glue_plotly/common/tests/test_histogram.py

@@ -99,8 +99,6 @@ def test_basic_trace(self):
         assert len(traces) == 1
         trace = traces[0]
         assert isinstance(trace, Bar)
-        edges, _ = self.layer.state.histogram
-        assert trace['width'] == edges[1] - edges[0]
 
     def test_log_trace(self):
         self.viewer.state.x_log = True

glue_plotly/html_exporters/__init__.py

@@ -1,7 +0,0 @@
-from . import scatter2d  # noqa
-from . import scatter3d  # noqa
-from . import image # noqa
-from . import histogram  # noqa
-from . import profile  # noqa
-from . import table  # noqa
-from . import dendrogram  # noqa

glue_plotly/html_exporters/bqplot/__init__.py

@@ -0,0 +1,4 @@
+from . import histogram  # noqa
+from . import image  # noqa
+from . import profile  # noqa
+from . import scatter2d  # noqa