lessPython 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

lessPy/plotly_utils.py

@@ -17,6 +17,43 @@ BASE_COLORS = [
     "#00A3BA", "#D26FAF", "#00A76F", "#BD76CB",
 ]
 
+
+def theme_palette(theme=None):
+    """The palette a color theme gives to groups. R analog: .get_fill()
+    (not divergent): the qualitative hues for the default theme, else a
+    sequential palette in the theme's hue."""
+    from .utils import get_option
+    if theme is None:
+        theme = get_option("theme", "colors")
+    if theme == "colors":
+        return "hues"
+    for pal, members in (
+            ("grays", ("gray", "white")),
+            ("blues", ("lightbronze", "dodgerblue", "blue")),
+            ("browns", ("gold", "brown", "sienna")),
+            ("rusts", ("orange",)),
+            ("reds", ("darkred", "red", "rose", "slatered")),
+            ("greens", ("darkgreen", "green")),
+            ("violets", ("purple",))):
+        if theme in members:
+            return pal
+    return "blues"
+
+
+def by_colors(n, theme=None):
+    """One color per group of a by variable under the current theme,
+    as X() and XY() draw them. R analog: .color_range(.get_fill(theme),
+    n), two grays set apart as gray60 and gray30."""
+    pal = theme_palette(theme)
+    if pal == "hues":
+        return [BASE_COLORS[i % len(BASE_COLORS)] for i in range(n)]
+    if pal == "grays" and n == 2:
+        return ["#999999", "#4D4D4D"]
+    from .getColors import getColors
+    cols = getColors(pal, n=max(1, n), quiet=True)
+    return [c[:7] if len(c) == 9 else c for c in cols]
+
+
 # minimal named-color table; R's col2rgb() knows all R names, but
 # plotly accepts CSS names directly so unknowns pass through as-is
 _NAMED = {
@@ -80,6 +117,10 @@ def to_hex(col):
     gray = _gray_level(lower)
     if gray is not None:
         return gray
+    # any of R's named colors, as col2rgb() resolves them
+    from .rcolors import R_COLORS
+    if lower in R_COLORS:
+        return R_COLORS[lower]
     return c1        # CSS name unknown to us; plotly handles it
 
 
@@ -222,11 +263,15 @@ def legend_style(by_name, style_opts, title=None, position=None,
     leg = dict(
         title=dict(text=abbrev(text, abbrev_n) or "",
                    font=dict(size=round(
-                       15 * get_option("lab_size", 1) * mult))),
+                       15 * get_option("lab_size", 1) * mult),
+                       color=as_plotly_color(style_opts["lab_color"]))),
+        # the legend reads in the theme's label color, light on the
+        #   black sub_theme as the axis labels are
         font=dict(size=round(
-            16 * get_option("axis_size", 0.9) * mult)),
-        bgcolor=to_hex(style_opts["window_fill"]),
-        bordercolor=to_hex(style_opts["legend_border"]),
+            16 * get_option("axis_size", 0.9) * mult),
+            color=as_plotly_color(style_opts["lab_color"])),
+        bgcolor=as_plotly_color(style_opts["window_fill"]),
+        bordercolor=as_plotly_color(style_opts["legend_border"]),
         borderwidth=1,
     )
     # placement stays plotly's own unless asked for, so the callers
@@ -315,12 +360,27 @@ def axis_format(vals, digits_d=2, axis_fmt="K", prefix=""):
     return base
 
 
+_R_DASH = {"dashed": "dash", "dotted": "dot",
+           "dotdash": "dashdot", "longdash": "longdash",
+           "twodash": "longdashdot"}
+
+
+def r_dash(lty):
+    """An R line type name as plotly's dash, such as "dotted" to
+    "dot"; plotly's own names and None pass through. R analog: lty"""
+    return _R_DASH.get(lty, lty) if isinstance(lty, str) else lty
+
+
 def grid_style():
-    """R analog: .grid_style()"""
+    """R analog: .grid_style(). A sub_theme sets the grid through
+    grid_x_color / grid_y_color (white on the gray panel of "default"),
+    which take precedence over the grid color itself"""
+    clr = (get_option("grid_y_color") or get_option("grid_x_color")
+           or get_option("grid_col", "gray85"))
     return {
-        "color": to_hex(get_option("grid_col", "gray85")),
+        "color": as_plotly_color(clr),
         "width": get_option("grid_lwd", 0.5),
-        "dash": get_option("grid_lty", None),
+        "dash": r_dash(get_option("grid_lty", None)),
     }
 
 
@@ -355,27 +415,36 @@ def y_grid(y_vals):
 
 
 def axis_base():
-    """R analog: axis_base()"""
+    """R analog: axis_base(). A sub_theme sets the axes through their
+    own settings, so on sub_theme="black" the axis line and its labels
+    are light where axis_color stays dark; the labels are text, so they
+    take axis_text_color, as lessR's base R axes do"""
+    ax_line = (get_option("axis_x_color")
+               or get_option("axis_color", "black"))
+    ax_text = (get_option("axis_x_text_color")
+               or get_option("axis_text_color")
+               or get_option("axis_color", "black"))
     return {
         "zeroline": False,
         "showline": True,
-        "linecolor": to_hex(get_option("axis_color", "black")),
+        "linecolor": as_plotly_color(ax_line),
         "linewidth": get_option("axis_lwd", 1),
         "ticks": "outside",
         "ticklen": 4,
+        "tickcolor": as_plotly_color(ax_line),
         "automargin": True,
         "tickfont": {
-            "color": to_hex(get_option("axis_color", "black")),
+            "color": as_plotly_color(ax_text),
             "size": 16 * get_option("axis_size", 0.9),
         },
         "title": {
             "font": {
-                "color": to_hex(get_option("lab_color", "black")),
+                "color": as_plotly_color(get_option("lab_color", "black")),
                 "size": 15 * get_option("lab_size", 1),
             },
             "standoff": 10,
         },
-        "gridcolor": to_hex(get_option("grid_color", "gray90")),
+        "gridcolor": as_plotly_color(get_option("grid_color", "gray90")),
         "gridwidth": get_option("grid_lwd", 1),
     }
 
@@ -445,7 +514,7 @@ def add_subtitle(fig, sub):
     title_size = round(16 * get_option("main_size", 1))
     size = round(title_size * get_option("sub_size", 0.75) / 0.75
                  * 0.75)
-    color = to_hex(get_option("sub_color",
+    color = as_plotly_color(get_option("sub_color",
                               get_option("main_color",
                                          get_option("lab_color",
                                                     "black"))))
@@ -486,6 +555,10 @@ def font_scaled(func):
         fig = func(*args, **kwargs)
         if sub and hasattr(fig, "layout"):
             add_subtitle(fig, sub)
+        # style(font_family=) sets the family of all plotted text
+        family = get_option("font_family")
+        if family and hasattr(fig, "layout"):
+            fig.update_layout(font=dict(family=family))
         try:
             if font_size and font_size != 1 and hasattr(fig, "layout"):
                 apply_font_size(fig, font_size)
@@ -496,13 +569,66 @@ def font_scaled(func):
     return wrapper
 
 
-def sym_at(shape, i):
-    """Per-group marker symbol. A scalar shape is used for every
-    group (by= differentiates by color only, the default); a list/
-    tuple gives one symbol per group, recycled if short."""
+# R's pch codes 0-25 as plotly symbols; 21-25 are lessR's named
+# shapes. R analog: .plt.shapes(), and points() for the open codes
+_R_PCH = {
+    0: "square-open", 1: "circle-open", 2: "triangle-up-open",
+    3: "cross-thin-open", 4: "x-thin-open", 5: "diamond-open",
+    6: "triangle-down-open", 7: "square-x-open",
+    8: "asterisk-open", 9: "diamond-cross-open",
+    10: "circle-cross-open", 11: "hexagram-open",
+    12: "square-cross-open", 13: "circle-x-open",
+    14: "square-open", 15: "square", 16: "circle",
+    17: "triangle-up", 18: "diamond", 19: "circle", 20: "circle",
+    21: "circle", 22: "square", 23: "diamond", 24: "triangle-up",
+    25: "triangle-down"}
+_LESSR_SHAPES = {"triup": "triangle-up", "tridown": "triangle-down"}
+# pt_shape="vary": one shape per by group, in lessR's order
+_VARY = (["triup", "tridown", "circle", "square", "diamond",
+          8, 7, 9, 10, 12, 13, 14, 11]
+         + list("abcdefghijklmnopqrstuvwxyz")
+         + list("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+         + list("+*#%!=-&$?|><@./;:"))
+
+
+def shape_at(shape, i):
+    """Per-group shape as (plotly symbol, None), or (None, char) for
+    a single character, drawn as text, as R's pch="$". A scalar
+    shape is used for every group (by= differentiates by color
+    only, the default); a list gives one shape per group, recycled;
+    "vary" a different shape per group. Takes plotly's names,
+    lessR's triup/tridown, and R's pch codes 0-25.
+    R analog: .plt.shapes()"""
+    if isinstance(shape, str) and shape == "vary":
+        shape = _VARY
     if isinstance(shape, (list, tuple)):
-        return shape[i % len(shape)]
-    return shape
+        shape = shape[i % len(shape)]
+    if isinstance(shape, (int, np.integer)) and not isinstance(
+            shape, bool):
+        if int(shape) not in _R_PCH:
+            raise ValueError(
+                f"pt_shape={shape}: R's numbered shapes are 0 to 25")
+        return _R_PCH[int(shape)], None
+    s = str(shape)
+    if len(s) == 1:
+        return None, s
+    return _LESSR_SHAPES.get(s, s), None
+
+
+def marks(shape, i, mode, marker):
+    """go.Scatter keywords that draw the points of group i: the
+    marker with its symbol, or for a character shape the
+    character as text in the marker's border color, sized to the
+    marker. mode is "markers" or "lines+markers"."""
+    sym, ch = shape_at(shape, i)
+    if ch is None:
+        return dict(mode=mode, marker=dict(marker, symbol=sym))
+    color = (marker.get("line") or {}).get("color", marker.get("color"))
+    return dict(mode=mode.replace("markers", "text"), text=ch,
+                textposition="middle center",
+                textfont=dict(color=color,
+                              size=max(8, round(float(np.median(
+                                  marker.get("size", 8))) * 1.4))))
 
 
 def square_layout(main=False, side=460):
@@ -603,7 +729,7 @@ def facet_panels(facet, facet_order, facet2=None,
 
 def finish_facet(fig, levels, ax, x_lab, y_lab, gridT1,
                  style_opts=None, y_cat=None, n_col=1, pos=None,
-                 height=None, width=None):
+                 height=None, width=None, x_cat=None):
     """Facet styling shared by the faceted renderers: per-panel y
     axes on a common scale (y label on the middle panel of the
     first column), x ticks on the bottom row only, vertical grid
@@ -631,8 +757,8 @@ def finish_facet(fig, levels, ax, x_lab, y_lab, gridT1,
     anns = list(fig.layout.annotations or [])
     s_fill = as_plotly_color(get_option("strip_fill",
                                         "#7F7F7F37"))
-    s_line = to_hex(get_option("strip_color", "gray40"))
-    s_text = to_hex(get_option("strip_text_color", "gray15"))
+    s_line = as_plotly_color(get_option("strip_color", "gray40"))
+    s_text = as_plotly_color(get_option("strip_text_color", "gray15"))
     strip_h = max(0.10, min(0.30, 0.05 * n_row))
     # strip font: shrink so the longest label fits its panel
     # (the two-facet  Var = "level"  cell labels run long)
@@ -654,7 +780,7 @@ def finish_facet(fig, levels, ax, x_lab, y_lab, gridT1,
         if y_cat is None:
             ay = axis_num(show_ylab, ax["axT2"], ax["axL2"])
             ay.update(showgrid=True,
-                      gridcolor=to_hex(style_opts["grid_col"]),
+                      gridcolor=as_plotly_color(style_opts["grid_col"]),
                       gridwidth=1, griddash="dot",
                       showticklabels=c == 1,
                       range=[0, float(ax["axT2"][-1]) * 1.04])
@@ -670,7 +796,14 @@ def finish_facet(fig, levels, ax, x_lab, y_lab, gridT1,
                       showticklabels=c == 1)
         fig.update_yaxes(row=r, col=c, **ay)
         lowest = r == n_row or (r + 1, c) not in occupied
-        if lowest:
+        if lowest and x_cat is not None:
+            # categories along x, the vertical bars of a panel
+            ax_x = axis_cat(x_lab if c == mid_c else "")
+            ax_x.update(categoryorder="array",
+                        categoryarray=list(x_cat), tickmode="array",
+                        tickvals=list(x_cat), ticktext=list(x_cat))
+            fig.update_xaxes(row=r, col=c, showticklabels=True, **ax_x)
+        elif lowest:
             # a shared x axis hides the labels above the bottom row,
             #   so a ragged grid's lowest panel turns its own back on
             fig.update_xaxes(
@@ -680,7 +813,7 @@ def finish_facet(fig, levels, ax, x_lab, y_lab, gridT1,
         else:
             fig.update_xaxes(
                 row=r, col=c, showline=True, ticks="",
-                linecolor=to_hex(get_option("axis_color",
+                linecolor=as_plotly_color(get_option("axis_color",
                                             "black")))
         for v in (gridT1 or []):          # vertical panel grid
             shapes.append({
@@ -693,7 +826,7 @@ def finish_facet(fig, levels, ax, x_lab, y_lab, gridT1,
             "type": "rect",
             "xref": f"x{suf} domain", "yref": f"y{suf} domain",
             "x0": 0, "x1": 1, "y0": 0, "y1": 1,
-            "line": {"color": to_hex("gray75"), "width": 1},
+            "line": {"color": as_plotly_color("gray75"), "width": 1},
             "fillcolor": "rgba(0,0,0,0)"})
         shapes.append({                   # strip label band
             "type": "rect",
@@ -718,8 +851,8 @@ def finish_facet(fig, levels, ax, x_lab, y_lab, gridT1,
 
     layout_kw = dict(
         shapes=shapes, annotations=anns, template=None,
-        plot_bgcolor=to_hex(style_opts["panel_fill"]),
-        paper_bgcolor=to_hex(style_opts["window_fill"]),
+        plot_bgcolor=as_plotly_color(style_opts["panel_fill"]),
+        paper_bgcolor=as_plotly_color(style_opts["window_fill"]),
         height=height if height is not None else 140 + 160 * n_row,
     )
     if width is not None:
@@ -814,7 +947,7 @@ def plot_border(top=True, right=True, color=None, width=None):
     if isinstance(color, str) and re.fullmatch(r"gray\d+", color):
         color = "gray75"   # make a gray a little lighter for plotly
 
-    line = {"color": to_hex(color), "width": width}
+    line = {"color": as_plotly_color(color), "width": width}
     out = []
     if top:
         out.append({"type": "line", "xref": "paper", "yref": "paper",

lessPy/plt_add.py

@@ -13,14 +13,9 @@
 import numpy as np
 import plotly.graph_objects as go
 
-from .plotly_utils import as_plotly_color, make_trans, to_hex
+from .plotly_utils import as_plotly_color, make_trans, r_dash, to_hex
 from .utils import get_option
 
-_DASH = {"dashed": "dash", "dotted": "dot",
-         "dotdash": "dashdot", "longdash": "longdash",
-         "twodash": "longdashdot"}
-
-
 def _as_list(v):
     if v is None:
         return []
@@ -86,7 +81,7 @@ def plt_add(fig, add, x1=None, x2=None, y1=None, y2=None):
                   else as_plotly_color(fll))
         line = dict(color=col, width=max(0.5, lwd * 2))
         if lty != "solid":
-            line["dash"] = _DASH.get(lty, lty)
+            line["dash"] = r_dash(lty)
 
         for xx1, yy1, xx2, yy2 in locs(obj):
             if obj == "v_line":

lessPy/plt_contour.py

@@ -14,7 +14,7 @@ import plotly.graph_objects as go
 from scipy import stats as sps
 
 from .plotly_utils import (
-    axis_format, axis_num, get_tick_fmt, plot_border,
+    as_plotly_color, axis_format, axis_num, get_tick_fmt, plot_border,
     plotly_style, to_hex)
 from .utils import get_option, pretty
 
@@ -134,7 +134,7 @@ def plt_contour(xv, yv, contour_n, contour_nbins, contour_points,
         showscale=bool(legend),
         colorbar=dict(
             tickfont=dict(
-                color=to_hex(get_option("axis_color", "black")),
+                color=as_plotly_color(get_option("axis_color", "black")),
                 size=16 * get_option("axis_size", 0.9)),
             outlinewidth=0),
         hovertemplate=(f"{x_lab}: {xpart}<br>{y_lab}: {ypart}"
@@ -158,7 +158,7 @@ def plt_contour(xv, yv, contour_n, contour_nbins, contour_points,
     for ex_l, ey_l in ellipses or []:
         fig.add_trace(go.Scatter(
             x=ex_l, y=ey_l, mode="lines",
-            line=dict(color=to_hex(ellipse_color),
+            line=dict(color=as_plotly_color(ellipse_color),
                       width=ellipse_lwd),
             hoverinfo="skip", showlegend=False))
 
@@ -167,7 +167,7 @@ def plt_contour(xv, yv, contour_n, contour_nbins, contour_points,
             continue
         fig.add_trace(go.Scatter(
             x=fl["x"], y=fl["y"], mode="lines",
-            line=dict(color=to_hex(fit_color), width=fit_lwd),
+            line=dict(color=as_plotly_color(fit_color), width=fit_lwd),
             hoverinfo="skip", showlegend=False))
 
     ax_x = axis_num(x_lab, axT1, axL1)
@@ -178,8 +178,8 @@ def plt_contour(xv, yv, contour_n, contour_nbins, contour_points,
         xaxis=ax_x, yaxis=ax_y,
         shapes=plot_border(),
         template=None,
-        plot_bgcolor=to_hex(style_opts["panel_fill"]),
-        paper_bgcolor=to_hex(style_opts["window_fill"]),
+        plot_bgcolor=as_plotly_color(style_opts["panel_fill"]),
+        paper_bgcolor=as_plotly_color(style_opts["window_fill"]),
     )
 
     if main:

lessPy/plt_contour_facet.py

@@ -17,7 +17,7 @@ import numpy as np
 import plotly.graph_objects as go
 
 from .plotly_utils import (
-    axis_format, facet_fig, facet_panels, finish_facet,
+    as_plotly_color, axis_format, facet_fig, facet_panels, finish_facet,
     plotly_style, to_hex)
 from .plt_contour import _COLORSCALE, _bw_nrd, _kde2d
 from .plt_smooth import _RAMP as _SMOOTH_RAMP
@@ -159,7 +159,7 @@ def plt_contour_facet(xv, yv, facet_arr, facet_order, facet_name,
             ex, ey = ellipse_fn(xi, yi, float(lv))
             fig.add_trace(go.Scatter(
                 x=ex, y=ey, mode="lines",
-                line=dict(color=to_hex(ellipse_color),
+                line=dict(color=as_plotly_color(ellipse_color),
                           width=ellipse_lwd),
                 hoverinfo="skip", showlegend=False,
             ), row=row, col=col)
@@ -169,7 +169,7 @@ def plt_contour_facet(xv, yv, facet_arr, facet_order, facet_name,
             if okf.sum() >= 2:
                 fig.add_trace(go.Scatter(
                     x=xs[okf], y=f[okf], mode="lines",
-                    line=dict(color=to_hex(fit_color),
+                    line=dict(color=as_plotly_color(fit_color),
                               width=fit_lwd),
                     hoverinfo="skip", showlegend=False,
                 ), row=row, col=col)

lessPy/plt_mat_plotly.py

@@ -29,14 +29,28 @@ def _axis_ref(k, kind):
 
 
 def scatter_matrix(df, fit="lm", digits_d=2, cor_coef=True,
-                   main=None, band=True):
+                   main=None, band=True, form="scatter",
+                   contour_n=None, contour_nbins=50,
+                   contour_points=False, smooth_bins=128,
+                   smooth_power=0.25):
     """Scatterplot matrix of the columns of df, in column order.
     fit: "off" (no line, XY default), "lm" (Regression) or
     "loess". cor_coef=True puts the correlation in the upper
     triangle and the scatter below (~ .plt.mat, Regression);
     cor_coef=False draws the scatter in every off-diagonal cell,
     the symmetric matrix R's Logit uses (logit.4Pred). band adds
-    the fit's 95% confidence band. Returns a plotly Figure."""
+    the fit's 95% confidence band. form="contour" or "smooth"
+    draws each cell as its own kernel density over the cell's
+    range, 8 contour bands unless contour_n is given (a cell cannot
+    resolve the 20 of a single plot), any fit drawn without its
+    band. R analog: .plt.mat() panel.dens. Returns a plotly
+    Figure."""
+    if form not in ("scatter", "contour", "smooth"):
+        raise ValueError(
+            'A matrix renders its cells as form="scatter", "contour", '
+            f'or "smooth", so form="{form}" is not\navailable for a '
+            "matrix.")
+    contour_n = 8 if contour_n is None else int(contour_n)
     cols = list(df.columns)
     n = len(cols)
     if n < 2:
@@ -54,12 +68,12 @@ def scatter_matrix(df, fit="lm", digits_d=2, cor_coef=True,
     bg = window_fill if panel_fill == "transparent" else panel_fill
     diag_fill = get_option("se_fill", "#1A1A1A19")
     se_fill = get_option("se_fill", "#1A1A1A19")
-    border = to_hex(style["panel_border"])
+    border = as_plotly_color(style["panel_border"])
     pt_fill = get_option("pt_fill", get_option("pt_color",
                                                "#324E5C"))
     pt_color = get_option("pt_color", "#324E5C")
-    lab_color = to_hex(style["lab_color"])
-    fit_color = to_hex(get_option("fit_color", "#5C4032"))
+    lab_color = as_plotly_color(style["lab_color"])
+    fit_color = as_plotly_color(get_option("fit_color", "#5C4032"))
     fit_lwd = get_option("fit_lwd", 2)
 
     # sizes shrink with the variable count, as R's cex.adj
@@ -78,6 +92,17 @@ def scatter_matrix(df, fit="lm", digits_d=2, cor_coef=True,
 
             # scatter in the lower triangle, and also in the
             # upper triangle when no correlations are requested
+            if r != c and (r > c or not cor_coef) \
+                    and form != "scatter":
+                _cell_bg(fig, xr, yr, bg, border)
+                _density_cell(fig, r, c, vals[cols[c - 1]],
+                              vals[cols[r - 1]], rng[cols[c - 1]],
+                              rng[cols[r - 1]], form, contour_n,
+                              contour_nbins, contour_points,
+                              smooth_bins, smooth_power,
+                              fit if do_fit else "off", fit_color,
+                              fit_lwd)
+                continue
             if r != c and (r > c or not cor_coef):
                 _cell_bg(fig, xr, yr, bg, border)
                 _scatter_cell(fig, r, c, vals[cols[c - 1]],
@@ -135,8 +160,8 @@ def scatter_matrix(df, fit="lm", digits_d=2, cor_coef=True,
 
     fig.update_layout(
         template=None, showlegend=False,
-        plot_bgcolor=to_hex(bg),
-        paper_bgcolor=to_hex(window_fill))
+        plot_bgcolor=as_plotly_color(bg),
+        paper_bgcolor=as_plotly_color(window_fill))
     if main:
         fig.update_layout(title=dict(
             text=main, x=0.5, xanchor="center",
@@ -182,16 +207,17 @@ def _scatter_cell(fig, r, c, xv, yv, fit, do_fit, px,
                                         (f - tq * se_f)[::-1]]))
             else:
                 poly = _se_band(xs, ys_s, f, 0.95)
-            fig.add_trace(go.Scatter(
-                x=poly[0], y=poly[1], mode="none", fill="toself",
-                fillcolor=as_plotly_color(se_fill),
-                hoverinfo="skip", showlegend=False), row=r, col=c)
+            if poly is not None:
+                fig.add_trace(go.Scatter(
+                    x=poly[0], y=poly[1], mode="none", fill="toself",
+                    fillcolor=as_plotly_color(se_fill),
+                    hoverinfo="skip", showlegend=False), row=r, col=c)
 
     fig.add_trace(go.Scatter(
         x=xv, y=yv, mode="markers",
         marker=dict(symbol="circle", size=px, sizemode="diameter",
                     color=make_trans(pt_fill, 0.9), opacity=1,
-                    line=dict(color=to_hex(pt_color), width=0.5)),
+                    line=dict(color=as_plotly_color(pt_color), width=0.5)),
         hoverinfo="x+y", showlegend=False), row=r, col=c)
 
     if do_fit and len(xv) >= 2:
@@ -199,3 +225,50 @@ def _scatter_cell(fig, r, c, xv, yv, fit, do_fit, px,
             x=xs, y=f, mode="lines",
             line=dict(color=fit_color, width=fit_lwd),
             hoverinfo="skip", showlegend=False), row=r, col=c)
+
+
+def _density_cell(fig, r, c, xv, yv, xr, yr, form, contour_n,
+                  contour_nbins, contour_points, smooth_bins,
+                  smooth_power, fit, fit_color, fit_lwd):
+    """One cell as a kernel density over the cell's range: filled
+    contour bands or the smooth shading, then the fit, unbanded.
+    R analog: panel.dens of .plt.mat()"""
+    from .plt_contour import _COLORSCALE, _bw_nrd, _kde2d
+    from .plt_smooth import _RAMP
+    from .XY import _loess, _plt_fit
+
+    ok = np.isfinite(xv) & np.isfinite(yv)
+    xo, yo = xv[ok], yv[ok]
+    if len(xo) < 3 or _bw_nrd(xo) <= 0 or _bw_nrd(yo) <= 0:
+        return
+    lims = (float(xr[0]), float(xr[-1]), float(yr[0]), float(yr[-1]))
+    n_grid = smooth_bins if form == "smooth" else contour_nbins
+    gx, gy, z = _kde2d(xo, yo, n_grid, lims)
+    if form == "smooth":
+        fig.add_trace(go.Heatmap(
+            x=gx, y=gy, z=(z ** smooth_power).T, colorscale=_RAMP,
+            zsmooth="best", showscale=False, hoverinfo="skip"),
+            row=r, col=c)
+    else:
+        lv0, lv1 = float(z.min()), float(z.max())
+        step = (lv1 - lv0) / contour_n
+        fig.add_trace(go.Contour(
+            x=gx, y=gy, z=z.T, colorscale=_COLORSCALE,
+            contours=dict(start=lv0 + step, end=lv1, size=step),
+            line=dict(width=0), showscale=False, hoverinfo="skip"),
+            row=r, col=c)
+        if contour_points:
+            fig.add_trace(go.Scatter(
+                x=xo, y=yo, mode="markers",
+                marker=dict(size=3, color="rgba(0,0,0,0.27)",
+                            line=dict(color="white", width=0.2)),
+                hoverinfo="skip", showlegend=False), row=r, col=c)
+    if fit in ("lm", "loess"):
+        if fit == "loess":
+            xs, _, f, _ = _loess(xo, yo, 2 / 3)
+        else:
+            xs, _, f = _plt_fit(xo, yo, "lm", 1)
+        fig.add_trace(go.Scatter(
+            x=xs, y=f, mode="lines",
+            line=dict(color=fit_color, width=fit_lwd),
+            hoverinfo="skip", showlegend=False), row=r, col=c)