datashader rasterize not supported?

[Jzege]

Describe the bug

Would Marimo be able to support DataShader's rasterise()?

In Jupyter, plots with millions of points can be rasterized before being sent to the browser .

E.g. https://holoviews.org/user_guide/Large_Data.html when converted to Marimo, the rasterized plots are not re-rendered when zoomed in.

Environment

Details

Replace this line with the output of marimo env. Leave the backticks in place.

Code to reproduce

https://holoviews.org/user_guide/Large_Data.html
https://raw.githubusercontent.com/holoviz/holoviews/main/examples/user_guide/15-Large_Data.ipynb

[mscolnick]

@Jzege, what specifically is not supported?

I currently am running the example you linked, and it seems like its working:

[Jzege]

Hello @mscolnick,

In the initial state, both Jupyter and Marimo will render the same thing:

Try zooming in (using another example so the difference is clearer):
Jupyter (points are re-rendered smaller):

Marimo (points scale up and become pixelated):

[mscolnick]

Thanks for clarifying. Just for reference, here is a smaller version of the ipynb notebook converted to marimo

Details

import marimo

__generated_with = "0.11.4"
app = marimo.App(width="medium")


@app.cell
def _():
    import datashader as ds
    import holoviews as hv
    import numpy as np
    import pandas as pd
    from holoviews import opts
    from holoviews.operation import decimate
    from holoviews.operation.datashader import (
        datashade,
        dynspread,
        rasterize,
        shade,
        spread,
    )
    from holoviews.operation.resample import ResampleOperation2D

    hv.extension("bokeh", "matplotlib", width=100)
    decimate.max_samples = 1000
    dynspread.max_px = 20
    dynspread.threshold = 0.5
    ResampleOperation2D.width = 500
    ResampleOperation2D.height = 500


    def random_walk(n, f=5000):
        """Random walk in a 2D space, smoothed with a filter of length f"""
        xs = np.convolve(np.random.normal(0, 0.1, size=n), np.ones(f) / f).cumsum()
        ys = np.convolve(np.random.normal(0, 0.1, size=n), np.ones(f) / f).cumsum()
        xs = xs + 0.1 * np.sin(0.1 * np.array(range(n - 1 + f)))
        xs = xs + np.random.normal(0, 0.005, size=n - 1 + f)
        ys = ys + np.random.normal(0, 0.005, size=n - 1 + f)
        return np.column_stack([xs, ys])


    def random_cov():
        """Random covariance for use in generating 2D Gaussian distributions"""
        A = np.random.randn(2, 2)
        return np.dot(A, A.T)


    def time_series(T=1, N=100, mu=0.1, sigma=0.1, S0=20):
        """Parameterized noisy time series"""
        dt = float(T) / N
        t = np.linspace(0, T, N)
        W = np.random.standard_normal(size=N)
        W = np.cumsum(W) * np.sqrt(dt)
        X = (mu - 0.5 * sigma**2) * t + sigma * W
        S = S0 * np.exp(X)
        return S
    return (
        ResampleOperation2D,
        datashade,
        decimate,
        ds,
        dynspread,
        hv,
        np,
        opts,
        pd,
        random_cov,
        random_walk,
        rasterize,
        shade,
        spread,
        time_series,
    )


@app.cell
def _(hv, np, random_walk):
    np.random.seed(1)
    points = hv.Points(
        np.random.multivariate_normal((0, 0), [[0.1, 0.1], [0.1, 1.0]], (1000,)),
        label="Points",
    )
    paths = hv.Path([random_walk(2000, 30)], kdims=["u", "v"], label="Paths")

    points + paths
    return paths, points


@app.cell
def _(hv, np, random_walk):
    np.random.seed(1)
    points_1 = hv.Points(
        np.random.multivariate_normal((0, 0), [[0.1, 0.1], [0.1, 1.0]], (1000000,)),
        label="Points",
    )
    paths_1 = hv.Path(
        [0.15 * random_walk(100000) for i in range(10)],
        kdims=["u", "v"],
        label="Paths",
    )
    return paths_1, points_1


@app.cell
def _(datashade, decimate, points_1, rasterize):
    points2 = decimate(points_1, dynamic=False, max_samples=3000)
    points2.opts(color="green", size=6, marker="s")
    (
        points2
        + rasterize(points2).relabel("Rasterized")
        + datashade(points2).relabel("Datashaded")
    )
    return (points2,)


@app.cell
def _(datashade, points2, rasterize, spread):
    w = 225

    (
        points2
        + spread(rasterize(points2, width=w, height=w), px=4, shape="square")
        .opts(cmap=["green"])
        .relabel("Rasterized")
        + spread(
            datashade(points2, width=w, height=w, cmap=["green"]),
            px=4,
            shape="square",
        ).relabel("Datashaded")
    )
    return (w,)


@app.cell
def _():
    import bokeh.palettes as bp

    greens = bp.Greens[256][::-1][64:]
    return bp, greens


@app.cell
def _(datashade, greens, points2, rasterize, spread, w):
    (
        points2
        + spread(rasterize(points2, width=w, height=w), px=4, shape="square")
        .opts(cmap=greens, cnorm="eq_hist")
        .relabel("Rasterized")
        + spread(
            datashade(points2, width=w, height=w, cmap="green", cnorm="eq_hist"),
            px=4,
            shape="square",
        ).relabel("Datashaded")
    )
    return


@app.cell
def _():
    import marimo as mo
    return (mo,)


if __name__ == "__main__":
    app.run()

@philippjfr, do you know if the bokeh rasterize features use something in Panel that hasn't been implemented yet in marimo.

[mb-915]

Hello, I opened a discussion recently for the same issue: #3751 , containing a minimal example using hvplot.

What is strange is that hvplot downsample work on wasm but not on native. (I could not try with datashading, though, as the datashader package is not supported by pyodide).

[jbednar]

The HoloViews rasterize operation depends on having bidirectional communication between JavaScript and Python, with a zoom event detected in the JavaScript code resulting in a callback to Python that re-renders the data and sends updates to the JavaScript. I don't know what support Marimo has for Panel these days, but if it supports bidirectional communication, then it should be possible to make this work.

[mb-915]

Other features of panel do work (#979 (comment)) but datashading do not : 

import marimo

__generated_with = "0.11.2"
app = marimo.App(width="medium")


@app.cell
def _():
    import colorcet as cc
    import holoviews as hv
    import hvplot.pandas
    import marimo as mo
    import numpy as np
    import pandas as pd
    import panel as pn

    pn.extension()
    return cc, hv, hvplot, mo, np, pd, pn


@app.cell
def _(cc, np, pd):
    rng = np.random.default_rng(12345)
    x = rng.normal(size=10_000_000)
    y = rng.normal(size=10_000_000)

    my_points = pd.DataFrame({"x": x, "y": y})
    datashaded_figure = my_points.hvplot.points(
        datashade=True, cmap=cc.fire, resample_when=10000
    ).opts(shared_axes=False)
    return datashaded_figure, my_points, rng, x, y


@app.cell
def _(datashaded_figure, hv, pn):
    pn.Column(
        datashaded_figure,
        (
            hv.DynamicMap(
                lambda v: hv.Curve([1, 2 * v, 3]).opts(title="Does work"),
                kdims=hv.Dimension("v", range=(0, 5), default=1),
            )
        ),
    )
    return


@app.cell
def _(datashaded_figure, pn):
    slider = pn.widgets.IntSlider(start=0, end=10, name="Does work")
    pn.Column(datashaded_figure, slider.rx() * "🎉")
    return (slider,)


@app.cell
def _(datashaded_figure, hv, pn):
    plot_slider = pn.widgets.IntSlider(start=0, end=10, name="Does work")
    pn.Column(datashaded_figure, pn.rx(lambda v: hv.Curve([1, 2 * v, 3]))(plot_slider))
    return (plot_slider,)


@app.cell
def _():
    return


if __name__ == "__main__":
    app.run()

[itsgifnotjiff]

Mr. @mscolnick thank you for your work!

Can you share any insight as to the feasability of a bidirectional communication feature for Holoviz libraries (Datashader, Geoviews, Holoviews and their wrapper HvPlot) please?

It is kind of the only thing keeping me and my colleagues from fully switching to Marimo.

[mscolnick]

I actually don't exactly know whats necessary. My guess is some hook / comms that we haven't implemented, but I haven't identified where or what that is. I can give it a look this week or next though.

[itsgifnotjiff]

I am not a Holoviz maintainer but it seems to me the part that makes it work in Jupyter Lab is this package. Does this help?

Mr. @bryevdv does this makes sense?

[philippjfr]

I'll have to take another look here but it is odd that other Panel functionality works but this does not. Could you try wrapping your HoloViews plot in a Panel layout and try if rendering that works

[itsgifnotjiff]

Is this what you meant Mr. @philippjfr ? I had tried it before but it did not work.

Screen.Recording.2025-03-28.181857.mp4

Something else that does not work is defining a panel app as a class then use its instantioation to populate a template and serve it.

app = AppClass()
template = pn.template.MaterialTemplate(
    site="Demo", 
    title="Demo Title",
    sidebar=[
        pn.Column(
            f"## Data Selection: {path}",
            pn.panel(app.ds) if ds is not None else "No data loaded"
        )
    ],
    sidebar_width=350
).servable()

In Jupyter you would see the Panel app in the output.