jarvisplot 2.1.1__tar.gz → 2.1.3__tar.gz

{jarvisplot-2.1.1 → jarvisplot-2.1.3}/JarvisPLOT.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 2.1.1
+Version: 2.1.3
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{jarvisplot-2.1.1 → jarvisplot-2.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 2.1.1
+Version: 2.1.3
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{jarvisplot-2.1.1 → jarvisplot-2.1.3}/jarvisplot/Figure/corr_layout_diamond.py

@@ -63,6 +63,15 @@ def diamond_extent(n: int, *, diag: bool = False) -> tuple[float, float, float,
 
     With ``diag`` the self-pairs come in at ``u = 0`` and push both ranges out
     by half a cell.
+
+    A half, not the quarter the pentagon of
+    :func:`corrplot_runtime._self_cell_vertices` actually reaches: that shape
+    is how a *fill* keeps a whole cell's area against the edge, and the round
+    glyphs do not take it.  A circle on the diagonal is a circle, and at the
+    quarter it overhung the panel by 0.07 cells -- which is only 0.3 mm, but it
+    is 0.3 mm off the one gap the eye checks, the channel between the matrix
+    and the names, and it narrowed it on the diagonal rows alone.  The panel
+    buys the half so that every glyph fits whatever shape it is.
     """
     n = max(int(n), 2)
     if diag:

{jarvisplot-2.1.1 → jarvisplot-2.1.3}/jarvisplot/Figure/corrplot_runtime.py

@@ -45,10 +45,15 @@ GLYPHS = ("circle", "square", "ellipse", "color", "shade", "pie", "number")
 
 _TRIANGLES = ("full", "upper", "lower")
 
+#: What the tint may be told to mean.  `selected` is the author's own grouping,
+#: `alternate` the figure's own, `none` nothing.
+_STRIPES = ("alternate", "selected", "none")
+
 #: Formals resolved at config time.  They arrive because the user wrote them
 #: in the layer, and are dropped here rather than forwarded to matplotlib.
 _CONFIG_TIME = ("order", "hclust.method", "addrect", "col", "tl.pos", "tl.cex",
-                "tl.col", "tl.srt", "tl.offset", "cl.cex", "edge.numbers.cex")
+                "tl.col", "tl.srt", "tl.offset", "cl.cex", "edge.numbers.cex",
+                "stripe.variables")
 
 
 def _pop(kwargs: dict, name: str, default=None):
@@ -161,6 +166,14 @@ _DIAMOND_ROUND = 1.0 / np.sqrt(2.0)
 #: because a divider that is *nearly* the cell divider reads as a mistake.
 _GRID_LWD = 0.3
 
+#: Where the tint sits: under everything.  It is the background the figure is
+#: drawn *on*, so it takes the lowest layer on the axes rather than one derived
+#: from the glyph's -- an axis draws its own tick labels at 2.5, and a tint
+#: placed relative to the glyphs lands above that and prints over the names.
+#: Its three pieces (the cells, the notch, the band under the label) are one
+#: band and share one number, so they cannot drift apart.
+_TINT_ZORDER = 0.4
+
 #: Square glyphs are a polygon per cell and nothing else, so they skip the
 #: patch objects entirely -- see :func:`_glyph_vertices`.
 _POLYGON_GLYPHS = ("square", "color", "shade")
@@ -171,21 +184,87 @@ _POLYGON_GLYPHS = ("square", "color", "shade")
 _FILLED_GLYPHS = ("color", "shade")
 
 
-def _notch_vertices(n: int, side: str = "left"):
+#: How far a self cell reaches past the matrix's near edge, in cells.  See
+#: :func:`_self_cell_vertices` -- it is what makes the pentagon's area a cell.
+_SELF_REACH = 0.25
+
+
+def _self_cell_vertices(rows, side: str = "left", scale: float = 1.0):
+    """``(m, 5, 2)`` outlines for the cells on the diagonal.
+
+    A variable's pair with *itself* sits at ``u = 0``, so half of an ordinary
+    cell would hang off the matrix and print over the names.  Clipping it
+    instead leaves a triangle -- half the area of every other cell, which reads
+    as a fainter diagonal rather than as the constant it is.
+
+    So it is neither: the cell keeps its point into the matrix and is squared
+    off on the outside, and the rectangle that squares it off is exactly deep
+    enough to pay back what the clip took.  The triangle is ``1/4``, the
+    rectangle is ``a x 1``, so ``a = 1/4`` puts the pentagon at ``1/2`` -- the
+    area of a whole cell, for every variable, which is the only way a diagonal
+    of constant rho can look constant.
+
+    It fits without moving anything: the wedge beside each name is empty by
+    construction (see :func:`_notch_vertices`, which is what used to fill it)
+    and the quarter cell outside is page the panel takes from the gap.
+
+    ``scale`` shrinks it about ``(0, k)`` exactly as ``glyph.scale`` shrinks
+    every other cell.  Without it these are the only shapes on the figure drawn
+    at full size, and since they also stack without a gap in ``v`` they fuse
+    into one bar down the edge instead of reading as a cell each.
+    """
+    k = np.asarray(rows, dtype=float)
+    flip = -1.0 if side == "right" else 1.0
+    zero = np.zeros_like(k)
+    half = 0.5 * float(scale)
+    back = flip * -2.0 * _SELF_REACH * half + zero
+    point, edge = flip * half + zero, half
+    return np.stack(
+        [
+            np.stack([back, k - edge], axis=1),
+            np.stack([zero, k - edge], axis=1),
+            np.stack([point, k], axis=1),
+            np.stack([zero, k + edge], axis=1),
+            np.stack([back, k + edge], axis=1),
+        ],
+        axis=1,
+    )
+
+
+def _notch_vertices(n: int, side: str = "left", diag: bool = False):
     """The half cells that make the matrix's near edge straight.
 
-    A variable's V has its vertex at ``(0, k)``, and the two cells meeting
-    there touch the edge at a point, not along it -- so the boundary beside the
-    names comes out as a row of notches.  The notch at ``k`` is the triangle
-    ``(0, k-1/2) (1/2, k) (0, k+1/2)``: filling it with that variable's own
-    tint carries the band from the name into the matrix without a gap, and
-    turns the sawtooth into the straight edge the rules can close against.
+    Whatever stands at ``u = 0`` meets the edge beside the names at a *point*,
+    so that boundary comes out as a row of notches and the tint carrying a
+    variable's band in from its name pinches to nothing there.  Filling the
+    notch is what turns the sawtooth into the straight edge the rules close
+    against, and the band into one band.
+
+    The diagonal moves the notch, it does not remove it -- which is what an
+    earlier version of this card assumed, and the band broke on every shaded
+    row.  Without the diagonal the near edge is ``u = 0`` and the first cells
+    are the pairs at ``u = 1/2``, so the gap is the triangle
+    ``(0, k-1/2) (1/2, k) (0, k+1/2)`` *inside* the matrix.  With it the near
+    edge is ``u = -1/2`` and the self cell's own left corner is the point, so
+    the gap is the pair of triangles either side of it -- together with that
+    corner, the rectangle ``[-1/2, 0] x [k-1/2, k+1/2]``.
 
     Returned for every variable; the caller picks the tinted ones.
     """
     k = np.arange(int(n), dtype=float)
     flip = -1.0 if side == "right" else 1.0
     zero = np.zeros_like(k)
+    if diag:
+        back = flip * -0.5 + zero
+        return np.stack(
+            [
+                np.stack([back, k - 0.5], axis=1),
+                np.stack([zero, k - 0.5], axis=1),
+                np.stack([zero, k + 0.5], axis=1),
+                np.stack([back, k + 0.5], axis=1),
+            ],
+            axis=1,
+        )
     return np.stack(
         [
             np.stack([zero, k - 0.5], axis=1),
@@ -196,14 +275,25 @@ def _notch_vertices(n: int, side: str = "left"):
     )
 
 
-def _shaded_variables(n: int, blocks=None) -> np.ndarray:
-    """Which variables carry the tint: alternate blocks, or alternate names.
+def _shaded_variables(n: int, blocks=None, selected=None) -> np.ndarray:
+    """Which variables carry the tint.
+
+    Three answers, and they say different things.  ``selected`` is an explicit
+    set of positions -- the author naming the variables that matter, so the
+    tint is *their* grouping and nothing is inferred.  Otherwise it is read off
+    the figure: alternate **blocks** when the clustering cut some, so the
+    shading says where one group ends and the next begins (which is what the
+    boxes were for), and alternate **names** when it did not.
 
-    A block is a run of adjacent positions cut from the clustering tree, so
-    tinting every other one makes the shading say where one group ends and the
-    next begins -- which is what the boxes were for.
+    ``selected`` arrives as positions, not names: the order is settled at
+    config time and only the order knows which position a name ended up at.
     """
     shaded = np.zeros(int(n), dtype=bool)
+    if selected is not None:
+        for position in selected:
+            if 0 <= int(position) < int(n):
+                shaded[int(position)] = True
+        return shaded
     if blocks:
         for position, (start, end) in enumerate(blocks):
             if position % 2 == 0:
@@ -329,13 +419,25 @@ def _label_rules(ax, n: int, span, color, lw: float, clip: bool,
     colour and weight rather than a nearby pair, because a divider that only
     nearly matches reads as a second, different thing.
 
+    It starts where the *cells* meet, not where the axes end.  Two cells of one
+    row touch at ``u = 0`` whichever layout is drawn -- without the diagonal
+    that is also the panel's near edge, so the two were the same number and the
+    difference never showed.  With the diagonal the panel reaches half a cell
+    further out, and a rule begun at the edge leaves that half cell unruled:
+    the line between two names starts in mid air instead of at the matrix.
+
     Below the tick labels, like the band: an axis draws its labels at zorder
     2.5, and a rule over one of them is a strike-through.
     """
     from matplotlib.collections import LineCollection
 
     target = ax.ax if hasattr(ax, "ax") else ax
-    x0, x1 = span
+    try:
+        lo, hi = target.get_xlim()
+        meet = (0.0 - float(lo)) / (float(hi) - float(lo))
+    except Exception:
+        meet = span[1] if span[0] < 0.0 else span[0]
+    x0, x1 = min(span[0], meet), max(span[1], meet)
     rules = LineCollection(
         [[(x0, k + 0.5), (x1, k + 0.5)] for k in range(int(n) - 1)],
         colors=color, linewidths=lw, zorder=0.6,
@@ -409,7 +511,7 @@ def _stripe_the_labels(ax, n: int, shaded, span, color, clip: bool) -> None:
         ax.axhspan(
             k - 0.5, k + 0.5, xmin=span[0], xmax=span[1],
             facecolor=color, edgecolor="none", linewidth=0.0,
-            zorder=0.5, clip_on=clip,
+            zorder=_TINT_ZORDER, clip_on=clip,
         )
 
 
@@ -464,7 +566,7 @@ def _glyph_vertices(kind: str, cx, cy, rho, scale: float, corners=None):
 
 
 def _glyph_patches(kind: str, cx, cy, rho, scale: float, sign: float,
-                   ellipse_scale: float = 1.4):
+                   ellipse_scale: float = 1.4, diamond: bool = False):
     """One matplotlib patch per drawn cell, in data coordinates.
 
     Only the round glyphs come through here; the square ones are built as bare
@@ -494,7 +596,22 @@ def _glyph_patches(kind: str, cx, cy, rho, scale: float, sign: float,
             # the box does not -- so at k = glyph.scale the widest one covers
             # 0.64 of the cell while a circle covers 0.9.  sqrt(2) is the
             # factor that makes the two agree, which is where 1.4 comes from.
+            #
+            # And it is the *cell's* diagonal, not the page's.  `ellipse` is
+            # the one glyph with a direction, and its direction means something
+            # about the two axes of the cell it sits in: turn the lattice 45
+            # degrees and leave the ellipse behind and every one of them is
+            # reporting the wrong pair.  The index map sends the cell's own
+            # frame through a +45 degree rotation (`j+1` goes to `(+1/2, +1/2)`
+            # and `i+1` to `(-1/2, +1/2)`), so the glyph turns with it.
+            #
+            # `side: right` negates u, which reflects rather than rotates and
+            # sends an angle A to 135 - A.  It needs no case of its own: the
+            # angle here is a constant +/-45, and 135 - A and A + 45 differ by
+            # 180 exactly when they differ at all -- and an ellipse's angle is
+            # read modulo 180.
             k = scale * ellipse_scale
+            lean = sign * 45.0 + (45.0 if diamond else 0.0)
             r = 0.0 if not np.isfinite(r) else float(np.clip(r, -1.0, 1.0))
             width = k * np.sqrt(max(1.0 + r, 0.0)) / np.sqrt(2.0)
             # |rho| = 1 collapses the minor axis to zero, which fills no
@@ -503,7 +620,7 @@ def _glyph_patches(kind: str, cx, cy, rho, scale: float, sign: float,
             # as a line, so the minor axis gets a hairline floor.
             height = max(k * np.sqrt(max(1.0 - r, 0.0)) / np.sqrt(2.0), 0.02 * k)
             patches.append(
-                Ellipse((x, y), width=width, height=height, angle=sign * 45.0)
+                Ellipse((x, y), width=width, height=height, angle=lean)
             )
         elif kind == "pie":
             # Clockwise from twelve o'clock, as read off the page.
@@ -627,9 +744,21 @@ def draw_corrplot(ax, **kwargs):
     # Diamond only.  See the stripe block below for why it is not decoration.
     stripe = _pop(kwargs, "stripe", "alternate")
     stripe = "none" if stripe is False else str(stripe).strip().lower()
-    if stripe not in ("alternate", "none"):
+    if stripe not in _STRIPES:
         raise ValueError(
-            "corrplot stripe must be alternate or none; got {!r}.".format(stripe)
+            "corrplot stripe must be one of {}; got {!r}. `selected` takes the "
+            "variables to tint in `stripe.variables`.".format(
+                ", ".join(_STRIPES), stripe
+            )
+        )
+    # Positions, resolved from `stripe.variables` at config time -- see
+    # `core_runtime._corr_shaded_positions`.  The names cannot be resolved here
+    # because `order` has already moved them.
+    shaded_positions = kwargs.pop("__corr_shaded__", None)
+    if stripe == "selected" and shaded_positions is None:
+        raise ValueError(
+            "corrplot stripe: selected needs stripe.variables -- the names to "
+            "tint. Without them the tint would say nothing."
         )
     stripe_color = _pop(kwargs, "stripe.col", "#EFEFEF")
     # Diamond only.  See `_edge_rules`: the rotated matrix has no top or bottom
@@ -721,14 +850,53 @@ def draw_corrplot(ax, **kwargs):
     if sig_level is not None and insig == "blank":
         drawn &= ~insignificant
 
+    # The diagonal, when it is in.  A self pair sits at `u = 0`, so anything
+    # built from an ordinary cell there hangs a quarter of a cell past the
+    # panel and prints over the names -- and everything on this figure except
+    # `_stripe_the_labels` is drawn well above the axis' own zorder of 2.5, so
+    # it prints *over* them, not under.  Every shape cut from a cell therefore
+    # takes the pentagon on the diagonal: the fill, the grid outline, and the
+    # tint.  See `_self_cell_vertices`.
+    self_cells = drawn & (index_x.astype(int) == index_y.astype(int))
+
+    def _with_self_cells(shapes, selection, closed_loop: bool, shape_scale=1.0):
+        """Swap the pentagon in wherever `shapes` covers a self pair.
+
+        `selection` is the mask over *all* cells that `shapes` was built from,
+        which is not the same mask each time -- the fill is drawn for `drawn`,
+        the tint for the shaded band, the grid for everything.
+        """
+        picked = self_cells[selection]
+        if not diamond or not np.any(picked):
+            return shapes
+        out = [np.asarray(shape) for shape in shapes]
+        pentagons = _self_cell_vertices(iy[selection & self_cells], side, shape_scale)
+        for slot, pentagon in zip(np.flatnonzero(picked), pentagons):
+            out[slot] = (
+                np.vstack([pentagon, pentagon[:1]]) if closed_loop else pentagon
+            )
+        return out
+
     label_span = _label_span(ax, side, label_column_mm) if diamond else None
 
     if diamond and edge_lwd > 0.0 and label_span is not None:
         # The column is a width in axes fractions; the outline is drawn in cell
-        # units, and the panel is `u_span` cells wide.
-        column_u = -label_span[0] * (n / 2.0) if side == "left" else (
-            (label_span[1] - 1.0) * (n / 2.0)
-        )
+        # units, so it is scaled by how many cells wide the panel is.  Read off
+        # the axes rather than worked out as `n / 2`: with the diagonal in, the
+        # panel is a quarter cell wider than that (see `diamond_extent`), and a
+        # rule scaled by the wrong span stops short of the names it is meant to
+        # close over -- by 4% of the column, which at thirteen variables is the
+        # last two letters of the longest name left hanging outside it.
+        lo, hi = float(min(ax.get_xlim())), float(max(ax.get_xlim()))
+        u_span = hi - lo
+        # ... and measured from the panel's own near edge, which the diagonal
+        # moves out to `u = -1/4`.  `_edge_rules` strikes the horizontal run
+        # from `-column_u` to `0`, so the near edge has to be added back in:
+        # left out, the rule stops a quarter cell short and the last letters of
+        # the longest name hang outside the box it is meant to close.
+        near_u = lo if side == "left" else -hi
+        column_u = (-label_span[0] if side == "left" else label_span[1] - 1.0)
+        column_u = column_u * u_span - near_u
         _edge_rules(ax, n, column_u, side, edge_color, edge_lwd, zorder + 40, clip)
     if diamond and grid_color and label_span is not None:
         _label_rules(ax, n, label_span, grid_color, _GRID_LWD, clip, zorder)
@@ -743,7 +911,7 @@ def draw_corrplot(ax, **kwargs):
                 edge_color, clip, zorder + 40,
             )
 
-    if diamond and stripe == "alternate" and np.any(drawn):
+    if diamond and stripe != "none" and np.any(drawn):
         # Every other variable's cells, tinted.  Not decoration: a variable's
         # pairs run away from its name as a V, and at 40 names a reader
         # following one of those arms has nothing to hold on to.  The band is
@@ -759,23 +927,29 @@ def draw_corrplot(ax, **kwargs):
         #
         # The union of those variables' cells rather than one band each, so a
         # cell where two bands cross is filled once and the tint stays even.
-        shaded = _shaded_variables(n, blocks)
+        shaded = _shaded_variables(n, blocks, shaded_positions)
         band = shaded[index_x.astype(int)] | shaded[index_y.astype(int)]
         band &= drawn
         if np.any(band):
+            # The tint is a background and keeps the plain cell, diagonal
+            # included: it has to reach the panel's edge or the band it carries
+            # from the name into the matrix comes apart there.  It can, because
+            # the panel buys the whole half cell -- which is also what stops it
+            # printing over the names, and that is a clearance, not a shape.
             cells = PolyCollection(
                 np.stack([ix[band], iy[band]], axis=1)[:, None, :]
                 + 0.5 * _DIAMOND_CORNERS[None, :, :],
                 closed=True, facecolors=stripe_color, edgecolors="none",
-                zorder=zorder - 20,
+                zorder=_TINT_ZORDER,
             )
             cells.set_clip_on(clip)
             ax.add_collection(cells)
         # The half cells beside the names, so the band reaches the matrix and
         # the edge it makes is straight enough for the rules to close against.
+        # The diagonal moves this, it does not remove it: see `_notch_vertices`.
         notches = PolyCollection(
-            _notch_vertices(n, side)[shaded], closed=True,
-            facecolors=stripe_color, edgecolors="none", zorder=zorder - 20,
+            _notch_vertices(n, side, diag)[shaded], closed=True,
+            facecolors=stripe_color, edgecolors="none", zorder=_TINT_ZORDER,
         )
         notches.set_clip_on(clip)
         ax.add_collection(notches)
@@ -790,9 +964,13 @@ def draw_corrplot(ax, **kwargs):
     else:
         if kind in _POLYGON_GLYPHS:
             artists = PolyCollection(
-                _glyph_vertices(
-                    kind, ix[drawn], iy[drawn], rho[drawn], scale,
-                    corners=_DIAMOND_CORNERS if diamond else _CORNERS,
+                _with_self_cells(
+                    _glyph_vertices(
+                        kind, ix[drawn], iy[drawn], rho[drawn], scale,
+                        corners=_DIAMOND_CORNERS if diamond else _CORNERS,
+                    ),
+                    drawn if kind in _FILLED_GLYPHS else np.zeros(ix.shape, dtype=bool),
+                    closed_loop=False, shape_scale=scale,
                 ),
                 closed=True,
             )
@@ -800,7 +978,7 @@ def draw_corrplot(ax, **kwargs):
             artists = PatchCollection(
                 _glyph_patches(
                     kind, ix[drawn], iy[drawn], rho[drawn], round_scale, sign,
-                    ellipse_scale=ellipse_scale,
+                    ellipse_scale=ellipse_scale, diamond=diamond,
                 ),
                 match_original=False,
             )
@@ -847,14 +1025,27 @@ def draw_corrplot(ax, **kwargs):
     if kind == "shade":
         # The sign is already in the colour; the hatch is what survives a
         # greyscale print, which is the whole point of shade.
+        #
+        # It runs corner to corner of the cell, and *which* corners is the
+        # layout's business.  On the square card those are the diagonal ones,
+        # `(+/-1, +/-1) * half`.  On the diamond the same cell is turned 45
+        # degrees, so its corners are the ones straight up and straight across
+        # -- and a stroke still drawn to `(+/-1, +/-1)` reaches `half * sqrt2`
+        # where the cell only reaches `half / sqrt2`: twice too long, over the
+        # boundary and into the neighbour, on every cell of the figure.
+        step = 0.5 * scale
+        arm = (
+            [(0.0, step), (step, 0.0)] if diamond else [(step, step), (step, -step)]
+        )
         hatch = LineCollection(
             [
                 [
-                    (x - 0.5 * scale, y - sign * 0.5 * scale * np.sign(r)),
-                    (x + 0.5 * scale, y + sign * 0.5 * scale * np.sign(r)),
+                    (x - dx, y - sign * dy * np.sign(r)),
+                    (x + dx, y + sign * dy * np.sign(r)),
                 ]
                 for x, y, r in zip(ix[drawn], iy[drawn], rho[drawn])
                 if r != 0.0
+                for dx, dy in [arm[0] if r > 0 else arm[1]]
             ],
             colors="#FFFFFF",
             linewidths=0.4,
@@ -868,9 +1059,23 @@ def draw_corrplot(ax, **kwargs):
         # picture, a quarter of the paths, and at 100 variables that is 40,000
         # of them.  The outline has to be per cell rather than n+1 ruled lines
         # because a `triangle` selection leaves holes for the ruling to cross.
+        # The pentagon is a shape for glyphs that *fill* their cell.  Outlining
+        # it under a round one would be drawing a boundary the glyph does not
+        # keep: at `rho = 1` the circle on the diagonal overhangs it, and the
+        # flat backs line up into a grey rail down the edge of the matrix with
+        # the circles straddling it.  So there the diagonal simply carries no
+        # outline -- the matrix's own edge is already closed by `edge.lwd`.
+        ruled = (
+            np.ones(ix.shape, dtype=bool)
+            if not diamond or kind in _FILLED_GLYPHS
+            else ~self_cells
+        )
         grid = LineCollection(
-            np.stack([ix, iy], axis=1)[:, None, :]
-            + (_DIAMOND_LOOP if diamond else _CELL_LOOP)[None, :, :],
+            _with_self_cells(
+                np.stack([ix[ruled], iy[ruled]], axis=1)[:, None, :]
+                + (_DIAMOND_LOOP if diamond else _CELL_LOOP)[None, :, :],
+                ruled, closed_loop=True,
+            ),
             colors=grid_color, linewidths=_GRID_LWD, zorder=zorder - 10,
         )
         grid.set_clip_on(clip)
@@ -914,7 +1119,7 @@ def draw_corrplot(ax, **kwargs):
     # block above), so a box around each of them would be the same fact drawn
     # twice, in the heaviest ink on the figure.  `addrect` still decides *what*
     # the blocks are; it just stops drawing them.
-    if blocks and not (diamond and stripe != "none"):
+    if blocks and not (diamond and stripe == "alternate"):
         for start, end in blocks:
             if diamond:
                 ax.add_patch(

{jarvisplot-2.1.1 → jarvisplot-2.1.3}/jarvisplot/cards/corrplot/diamond.json

@@ -496,9 +496,10 @@
     "Options": {
         "method": {"type": "enum", "values": ["circle", "square", "ellipse", "color", "shade", "pie", "number"], "default": "circle"},
         "type": {"type": "enum", "values": ["upper", "lower"], "default": "upper", "forbidden": ["full"]},
-        "diag": {"type": "boolean", "default": false},
+        "diag": {"type": "boolean", "default": true},
         "side": {"type": "enum", "values": ["left", "right"], "default": "right"},
-        "stripe": {"type": "enum", "values": ["alternate", "none"], "default": "alternate", "false_alias": "none"},
+        "stripe": {"type": "enum", "values": ["alternate", "selected", "none"], "default": "alternate", "false_alias": "none"},
+        "stripe.variables": {"type": "list_of_strings", "default": null, "requires": {"stripe": "selected"}},
         "order": {"type": "enum", "values": ["original", "AOE", "FPC", "hclust", "alphabet"], "default": "original"},
         "hclust.method": {"type": "enum", "values": ["single", "complete", "average", "weighted", "mcquitty", "median", "centroid", "ward.D", "ward.D2"], "default": "complete"},
         "addrect": {"type": "integer_or_null", "default": null, "requires": {"order": "hclust"}},
@@ -511,7 +512,7 @@
         "corrplot": {
             "method": "circle",
             "type": "upper",
-            "diag": false,
+            "diag": true,
             "glyph.scale": 0.9,
             "ellipse.scale": 1.4,
             "outline": "sign",

{jarvisplot-2.1.1 → jarvisplot-2.1.3}/jarvisplot/core_runtime.py

@@ -590,6 +590,47 @@ def _solve_corr_diamond(card, info, style, columns, axes_name):
     return geom, solved
 
 
+def _corr_shaded_positions(style: Mapping, columns, name: str):
+    """`stripe.variables` resolved against the order the figure ended up in.
+
+    It has to happen here and not at draw time.  The renderer sees positions,
+    and which position a variable holds is `order`'s answer, settled a moment
+    ago -- a name resolved against the *unordered* columns would tint a
+    different variable on every reordering and never say so.
+
+    A name that is not in the matrix is an error rather than a silent miss, for
+    the same reason: a tint that quietly did nothing is indistinguishable from
+    a tint that was not asked for.
+    """
+    stripe = style.get("stripe", "alternate")
+    stripe = "none" if stripe is False else str(stripe or "").strip().lower()
+    wanted = style.get("stripe.variables")
+    if wanted is None:
+        return None
+    if stripe != "selected":
+        raise ValueError(
+            "figure '{}' gives corrplot stripe.variables with stripe: {}. The "
+            "names are only read by stripe: selected; leaving them here would "
+            "draw the other tint and say nothing about them.".format(name, stripe)
+        )
+    if isinstance(wanted, str) or not isinstance(wanted, (list, tuple, set)):
+        raise ValueError(
+            "figure '{}' gives corrplot stripe.variables: {!r}. It takes a "
+            "list of variable names.".format(name, wanted)
+        )
+    at = {str(column): position for position, column in enumerate(columns)}
+    missing = [str(v) for v in wanted if str(v) not in at]
+    if missing:
+        raise ValueError(
+            "figure '{}' asks corrplot to tint {}, which {} not in the matrix. "
+            "The variables drawn are: {}.".format(
+                name, ", ".join(missing), "is" if len(missing) == 1 else "are",
+                ", ".join(str(c) for c in columns),
+            )
+        )
+    return sorted(at[str(v)] for v in wanted)
+
+
 def _as_corr_bool(value, default: bool = False) -> bool:
     if value is None:
         return default
@@ -895,8 +936,17 @@ def _prebuild_one(core, info: dict, card: Mapping) -> None:
     _enforce_corr_contract(info, contract, name)
 
     source = entry.get("source")
-    dts = (getattr(core, "dataset_registry", {}) or {}).get(
-        source if isinstance(source, str) else None
+    # A correlation layer may intentionally concatenate several root
+    # datasets.  The runtime already supports source lists; the prebuild only
+    # needs one member's cheap column metadata to solve the shared geometry.
+    # Use the first registered member (the input tables are required to carry
+    # the same schema), while leaving the complete source list for the actual
+    # correlation transform below.
+    registry = getattr(core, "dataset_registry", {}) or {}
+    source_names = [source] if isinstance(source, str) else list(source or [])
+    dts = next(
+        (registry.get(item) for item in source_names if isinstance(item, str) and registry.get(item) is not None),
+        None,
     )
     names = list(getattr(dts, "keys", None) or [])
     if not names:
@@ -991,6 +1041,11 @@ def _prebuild_one(core, info: dict, card: Mapping) -> None:
         # but placed and sized by the solve.
         layer["style"]["__corr_number_mm__"] = geom.number_pad_mm
         layer["style"]["__corr_number_pt__"] = geom.number_size_pt
+        # `stripe.variables` names variables; the renderer draws positions, and
+        # only the order settled above knows which is which.
+        shaded = _corr_shaded_positions(style, columns, info.get("name", "?"))
+        if shaded is not None:
+            layer["style"]["__corr_shaded__"] = shaded
 
     if blocks:
         # The boxes are cuts of the tree the order came from, so they are

{jarvisplot-2.1.1 → jarvisplot-2.1.3}/jarvisplot/manual_cards/method_notes.yaml

@@ -62,7 +62,7 @@ corrplot:
     - "Reserved: only the [corrplot, matrix] or [corrplot, diamond] style card provides its axes (axcorr / axccorr)."
     - "No coordinates needed — x_index / y_index / rho are the transform's own output columns."
     - "style takes R's formals: method (circle|square|ellipse|color|shade|pie|number), type, diag, glyph.scale, outline, addgrid.col, plus the card's own ellipse.scale."
-    - "Use [corrplot, matrix] for the square matrix; [corrplot, diamond] keeps one triangle, rotates it 45 degrees, and adds side: left|right (default right, which puts the triangle on the left of the page) plus stripe: alternate|none."
+    - "Use [corrplot, matrix] for the square matrix; [corrplot, diamond] keeps one triangle, rotates it 45 degrees, and adds side: left|right (default right, which puts the triangle on the left of the page) plus stripe: alternate|selected|none. stripe: selected takes the variables to tint in stripe.variables, resolved against the solved order; diag: true|false is the self-correlation on the diagonal, on by default."
     - "order (original|AOE|FPC|hclust|alphabet) and addrect are resolved before the figure is built, then written into the transform's `columns`."
     - "sig.level switches on the significance test; unlike R no p.mat is needed, because the table carries n per pair."
     - "The glyph is sized from the solved cell and the coefficient text is back-solved from it, so both survive the 170 mm width clamp."

{jarvisplot-2.1.1 → jarvisplot-2.1.3}/jarvisplot/manual_cards/type-correlation-matrix.yaml

@@ -45,7 +45,9 @@ human:
         `style: [corrplot, diamond]` picks the other card: the same matrix as
         one triangle turned 45 degrees, names in a plain column of horizontal
         text, each variable's pairs a V rooted at its own name. Same formals,
-        plus `side: left | right` (default `right`, the triangle on the left of the page) and `stripe: alternate | none`.
+        plus `side: left | right` (default `right`, the triangle on the left of the page) and `stripe: alternate | selected | none`
+        (`selected` names the variables in `stripe.variables`), plus
+        `diag: true | false` for the self-correlation on the diagonal.
     - kind: yaml
       title: Minimal figure
       lexer: yaml

{jarvisplot-2.1.1 → jarvisplot-2.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "JarvisPLOT"
-version = "2.1.1"
+version = "2.1.3"
 description = "Jarvis-PLOT: YAML-driven plotting engine"
 readme = "README.md"
 requires-python = ">=3.10"