How to create custom aggregation using FuncAggregator

[xhayden-veic]

Has anyone successfully been able to incorporate the FuncAggregator class to create their own custom data aggregation? The documentation is limited and simplified, and I've been having a doozy of a time getting it to work properly with my timeseries datasets. Below is my attempt at creating a class that inherits from DataAggregator to create a custom mean aggregation per window. Any examples or suggestions would be a huge help! Doesn't seem to be much customization.

`
class MeanAggregator(DataAggregator):
"""Custom Mean Aggregator for Plotly-Resampler to compute the mean per window."""

def _aggregate(self, x: np.ndarray | None, y: np.ndarray, n_out: int):
    """Aggregate y-values by computing the mean in each window.

    Parameters
    ----------
    x : np.ndarray | None
        The x-axis (time) values (can be None).
    y : np.ndarray
        The y-axis values to be aggregated.
    n_out : int
        Number of output points after downsampling.

    Returns
    -------
    Tuple[np.ndarray, np.ndarray]
        The selected x-values and aggregated mean y-values.
    """
    if x is None:
        x = np.arange(len(y))  # Default x if not provided

    if n_out >= len(y):
        return x, y  # No downsampling needed

    # Compute window size
    window_size = len(y) // n_out

    # Select evenly spaced x-values (avoid modifying x too much)
    x_selected = x[np.linspace(0, len(y) - 1, n_out, dtype=int)]

    # Compute mean per window for y-values
    y_means = np.array(
        [np.mean(y[i : i + window_size]) for i in range(0, len(y), window_size)]
    )[
        :n_out
    ]  # Ensure correct output size

    return x_selected, y_means  # Return properly formatted data

mean_aggregator = FuncAggregator(MeanAggregator)

fig = FigureResampler(go.Figure(), default_downsampler=mean_aggregator)

`
Apologies, not sure why the code is showing up a bit disjointed.

[xhayden-veic]

UPDATE:
I've been able to get something close to the desired effect. Instead of aggregating the mean value of the bins when resampling, We instead use the DataPointSelector class (as opposed to the DataAggregator class) to downsample the data set such that each bin chooses the point whose value is closest to the average of the values in that bin.
`
class MeanDownsampler(DataPointSelector):

def _arg_downsample(
    self,
    x: np.ndarray | None,
    y: np.ndarray,
    n_out: int,
) -> np.ndarray:
    if n_out >= len(y):
        return np.arange(len(y))

    # Calculate bin edges
    idxs = np.linspace(0, len(y), n_out + 1).astype(int)

    # Calculate the mean index for each bin
    mean_idxs = [
        start + np.argmin(np.abs(y[start:end] - np.mean(y[start:end])))
        for start, end in zip(idxs[:-1], idxs[1:])
    ]

    return np.array(mean_idxs)

mean_downsampler = MeanDownsampler()
`