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

@@ -142,15 +142,20 @@ def _nth_point(x, y, n_out):
         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))
 
 
 _ALGORITHMS = {
     'lttb': _lttb,
-    'nth': _nth_point
+    'nth': _nth_point,
+    'viewport': _viewport,
+    'viewport-xlim': _viewport,
 }
 
 
@@ -162,9 +167,11 @@ class downsample1d(ResampleOperation1D):
 
         - `lttb`: Largest Triangle Three Buckets downsample algorithm
         - `nth`: Selects every n-th point.
+        - `viewport`: Selects all points in a given viewport
+        - `viewport-xlim`: Selects all points in a given viewport, when xlim is set
     """
 
-    algorithm = param.Selector(default='lttb', objects=['lttb', 'nth'])
+    algorithm = param.Selector(default='lttb', objects=list(_ALGORITHMS))
 
     def _process(self, element, key=None):
         if isinstance(element, (Overlay, NdOverlay)):
@@ -176,7 +183,33 @@ 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]
+        elif self.p.algorithm == "viewport-xlim":
+            # We only want to send some of the data to the browser on the
+            # first pass if we have set xlim. This will render the plot and
+            # trigger a second pass with the x_range set. This will not work
+            # with the matplotlib backend because it does not update the x_range
+            # after the first pass, but that is not a problem because the matplotlib
+            # backend with the viewport algorithm does not make any sense.
+            # This is not very elegant.
+            size = element.dataset.shape[0]
+            mask1 = element.dataset.interface.select_mask(
+                element.dataset, {element.kdims[0]: slice(self.p.width // 2)},
+            )
+            mask2 = element.dataset.interface.select_mask(
+                element.dataset, {element.kdims[0]: slice(size - self.p.width // 2, size)},
+            )
+            element = element[mask1 | mask2]
+
         if len(element) <= self.p.width:
             return element
         xs, ys = (element.dimension_values(i) for i in range(2))

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):