Add viewport downsample algorithm

holoviews/core/data/cudf.py

@@ -231,6 +231,18 @@ def select_mask(cls, dataset, selection):
                 mask &= new_mask
         return mask
 
+    @classmethod
+    def _select_mask_neighbor(cls, dataset, selection):
+        """Runs select mask and expand the True values to include its neighbors
+
+        Example
+
+        select_mask =          [False, False, True, True, False, False]
+        select_mask_neighbor = [False, True,  True, True, True,  False]
+
+        """
+        raise NotImplementedError
+
     @classmethod
     def select(cls, dataset, selection_mask=None, **selection):
         df = dataset.data

holoviews/core/data/dask.py

@@ -154,6 +154,9 @@ def select_mask(cls, dataset, selection):
     def select(cls, dataset, selection_mask=None, **selection):
         df = dataset.data
         if selection_mask is not None:
+            import dask.array as da
+            if isinstance(selection_mask, da.Array):
+                return df.loc[selection_mask]
             return df[selection_mask]
         selection_mask = cls.select_mask(dataset, selection)
         indexed = cls.indexed(dataset, selection)
@@ -162,6 +165,23 @@ def select(cls, dataset, selection_mask=None, **selection):
             return df[dataset.vdims[0].name].compute().iloc[0]
         return df
 
+    @classmethod
+    def _select_mask_neighbor(cls, dataset, selection):
+        """Runs select mask and expand the True values to include its neighbors
+
+        Example
+
+        select_mask =          [False, False, True, True, False, False]
+        select_mask_neighbor = [False, True,  True, True, True,  False]
+
+        """
+        mask = cls.select_mask(dataset, selection)
+        mask = mask.to_dask_array().compute_chunk_sizes()
+        extra = mask[1:] ^ mask[:-1]
+        mask[1:] |= extra
+        mask[:-1] |= extra
+        return mask
+
     @classmethod
     def groupby(cls, dataset, dimensions, container_type, group_type, **kwargs):
         index_dims = [dataset.get_dimension(d) for d in dimensions]

holoviews/core/data/ibis.py

@@ -427,6 +427,18 @@ def select_mask(cls, dataset, selection):
                 predicates.append(column == object)
         return predicates
 
+    @classmethod
+    def _select_mask_neighbor(cls, dataset, selection):
+        """Runs select mask and expand the True values to include its neighbors
+
+        Example
+
+        select_mask =          [False, False, True, True, False, False]
+        select_mask_neighbor = [False, True,  True, True, True,  False]
+
+        """
+        raise NotImplementedError
+
     @classmethod
     def sample(cls, dataset, samples=None):
         import ibis

holoviews/core/data/interface.py

@@ -377,6 +377,21 @@ def select_mask(cls, dataset, selection):
                     mask &= index_mask
         return mask
 
+    @classmethod
+    def _select_mask_neighbor(cls, dataset, selection):
+        """Runs select mask and expand the True values to include its neighbors
+
+        Example
+
+        select_mask =          [False, False, True, True, False, False]
+        select_mask_neighbor = [False, True,  True, True, True,  False]
+
+        """
+        mask = cls.select_mask(dataset, selection)
+        extra = mask[1:] ^ mask[:-1]
+        mask[1:] |= extra
+        mask[:-1] |= extra
+        return mask
 
     @classmethod
     def indexed(cls, dataset, selection):

holoviews/operation/downsample.py

@@ -152,10 +152,13 @@ def _nth_point(x, y, n_out, **kwargs):
         y (np.ndarray): The y-values of the data.
         n_out (int): The number of output points.
     Returns:
-        np.array: The indexes of the selected datapoints.
+        slice: The slice of selected datapoints.
     """
     n_samples = len(x)
-    return np.arange(0, n_samples, max(1, math.ceil(n_samples / n_out)))
+    return slice(0, n_samples, max(1, math.ceil(n_samples / n_out)))
+
+def _viewport(x, y, n_out):
+    return slice(len(x))
 
 def _min_max(x, y, n_out, **kwargs):
     try:
@@ -191,6 +194,7 @@ def _m4(x, y, n_out, **kwargs):
 _ALGORITHMS = {
     'lttb': _lttb,
     'nth': _nth_point,
+    'viewport': _viewport,
     'minmax': _min_max,
     'minmax-lttb': _min_max_lttb,
     'm4': _m4,
@@ -209,11 +213,12 @@ class downsample1d(ResampleOperation1D):
 
         - `lttb`: Largest Triangle Three Buckets downsample algorithm
         - `nth`: Selects every n-th point.
+        - `viewport`: Selects all points in a given viewport
         - `minmax`: Selects the min and max value in each bin (requires tsdownsampler).
         - `m4`: Selects the min, max, first and last value in each bin (requires tsdownsampler).
         - `minmax-lttb`: First selects n_out * minmax_ratio min and max values,
-                         then further reduces these to n_out values using the
-                         Largest Triangle Three Buckets algorithm. (requires tsdownsampler)""")
+          then further reduces these to n_out values using the
+          Largest Triangle Three Buckets algorithm. (requires tsdownsampler)""")
 
     parallel = param.Boolean(default=False, doc="""
        The number of threads to use (if tsdownsampler is available).""")
@@ -233,7 +238,16 @@ def _process(self, element, key=None):
             return element.clone(elements)
 
         if self.p.x_range:
-            element = element[slice(*self.p.x_range)]
+            try:
+                mask = element.dataset.interface._select_mask_neighbor(
+                    element.dataset, {element.kdims[0]: self.p.x_range}
+                )
+            except NotImplementedError:
+                mask = slice(*self.p.x_range)
+            except Exception as e:
+                self.param.warning(f"Could not apply neighbor mask to downsample1d: {e}")
+                mask = slice(*self.p.x_range)
+            element = element[mask]
         if len(element) <= self.p.width:
             return element
         xs, ys = (element.dimension_values(i) for i in range(2))

holoviews/plotting/bokeh/callbacks.py

@@ -404,6 +404,7 @@ def set_callback(self, handle):
         if self.on_changes:
             change_handler = lambda attr, old, new: (
                 asyncio.create_task(self.on_change(attr, old, new))
+                 if self.plot.document else None
             )
             for change in self.on_changes:
                 if change in ['patching', 'streaming']:
@@ -645,6 +646,12 @@ class RangeXYCallback(Callback):
         'y1': 'cb_obj.y1',
     }
 
+    def initialize(self, plot_id=None):
+        super().initialize(plot_id)
+        for stream in self.streams:
+            msg = self._process_msg({})
+            stream.update(**msg)
+
     def _process_msg(self, msg):
         if self.plot.state.x_range is not self.plot.handles['x_range']:
             x_range = self.plot.handles['x_range']

holoviews/plotting/bokeh/plot.py

@@ -173,9 +173,6 @@ def _update_datasource(self, source, data):
         """
         Update datasource with data for a new frame.
         """
-        if not self.document:
-            return
-
         data = self._postprocess_data(data)
         empty = all(len(v) == 0 for v in data.values())
         if (self.streaming and self.streaming[0].data is self.current_frame.data

holoviews/streams.py

@@ -1480,6 +1480,10 @@ class RangeX(LinkedStream):
     x_range = param.Tuple(default=None, length=2, constant=True, doc="""
       Range of the x-axis of a plot in data coordinates""")
 
+    def _set_stream_parameters(self, **kwargs):
+        kwargs.pop("y_range", None)
+        super()._set_stream_parameters(**kwargs)
+
 
 class RangeY(LinkedStream):
     """
@@ -1489,6 +1493,10 @@ class RangeY(LinkedStream):
     y_range = param.Tuple(default=None, length=2, constant=True, doc="""
       Range of the y-axis of a plot in data coordinates""")
 
+    def _set_stream_parameters(self, **kwargs):
+        kwargs.pop("x_range", None)
+        super()._set_stream_parameters(**kwargs)
+
 
 class BoundsXY(LinkedStream):
     """

holoviews/tests/core/data/base.py

@@ -858,6 +858,12 @@ def test_dataset_transform_add_ht(self):
                              kdims=self.kdims, vdims=self.vdims+['combined'])
         self.assertEqual(transformed, expected)
 
+    def test_select_with_neighbor(self):
+        select = self.table.interface.select_mask(self.table.dataset, {"Weight": 18})
+        select_neighbor = self.table.interface._select_mask_neighbor(self.table.dataset, dict(Weight=18))
+
+        np.testing.assert_almost_equal(select, [False, True, False])
+        np.testing.assert_almost_equal(select_neighbor, [True, True, True])
 
 
 class ScalarColumnTests:

holoviews/tests/core/data/test_ibisinterface.py

@@ -256,6 +256,13 @@ def test_aggregation_operations(self):
 
             self.compare_dataset(expected, result, msg=str(agg))
 
+    def test_select_with_neighbor(self):
+        try:
+            # Not currently supported by Ibis
+            super().test_select_with_neighbor()
+        except NotImplementedError:
+            raise SkipTest("Not supported")
+
     if not IbisInterface.has_rowid():
 
         def test_dataset_iloc_slice_rows_slice_cols(self):