diff --git a/CLAUDE.md b/CLAUDE.md index f64fb11..d9456c5 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -470,9 +470,11 @@ as a grouped list does. Filling a page in is editing its `.md`; no Python follow can't tell apart: under `pathline.SEAM_BLUR` apart in OKLab (`ui/oklab.py`, THE perceptual colour distance — never a hue gap, never sRGB, both of which mis-size the greens against the cyans). There the seam is the **thin** chevron (`POWERLINE_THIN`) - in the previous chip's label colour, drawn on the next, so the ribbon runs on unbroken - and the join is a line the chip draws - on itself, never a wedge of page cut out of the route and never a third colour. An + halfway between the previous chip's label and fill (OKLab, `oklab.midpoint`; JP, + 2026-10-29 — it was the label itself), drawn on the next, so the ribbon runs on + unbroken and the join is a line the chip draws on itself out of its own pair, never a + wedge of page cut out of the route. The PicoCalc keeps the label: it has no slot + between a bright hue and its dim twin (`pathline._slot_seam`). An elision breaks the ribbon rather than joining it — bare `⋯` on the page between a closing point and the next chip's notch, no fill, no padding. - The ribbon's **outer ends**: the chevron means *the route continues*, so an end that is diff --git a/meshterm/ui/oklab.py b/meshterm/ui/oklab.py index 75def80..db9c025 100644 --- a/meshterm/ui/oklab.py +++ b/meshterm/ui/oklab.py @@ -121,6 +121,18 @@ def distance(first: str, second: str) -> float: return math.dist(from_hex(first), from_hex(second)) +def midpoint(first: str, second: str) -> str: + """The ``#rrggbb`` colour halfway between two ``#rrggbb`` colours, as the eye sees them. + + The function finds the average of the two colours in OKLab. Thus the result is halfway + in lightness and halfway in chroma to the eye. The average of two colours in the sRGB + gamut can be a little outside it, because the transform is not linear. :func:`fitted` + then lowers its chroma. + """ + (l1, a1, b1), (l2, a2, b2) = from_hex(first), from_hex(second) + return to_hex(fitted(((l1 + l2) / 2, (a1 + a2) / 2, (b1 + b2) / 2))) + + def shaded(colour: str, by: float, *, floor: float | None = None) -> str: """``colour`` moved ``by`` in lightness, away from the end of the scale that is nearer. diff --git a/meshterm/ui/pathline.py b/meshterm/ui/pathline.py index 61ae8c2..461f86f 100644 --- a/meshterm/ui/pathline.py +++ b/meshterm/ui/pathline.py @@ -25,9 +25,10 @@ surface that the survey found can in the end use it. keyless greys). Sometimes they have two fills that are too close to tell apart (less than :data:`SEAM_BLUR` apart in OKLab, the perceptual distance that :mod:`~meshterm.ui.oklab` measures). Then the interlock cannot draw the seam, and the - seam is the *thin* chevron instead. It has the colour of the label of the previous chip, - and it is drawn on the next chip. Thus the ribbon continues without a break, and the - join is a line that the chip draws on itself (:meth:`PathLine._seam`). + seam is the *thin* chevron instead. Its colour is halfway between the label and the fill + of the previous chip (on the 16-colour console, the label itself), and it is drawn on + the next chip. Thus the ribbon continues without a break, and the join is a line that + the chip draws on itself (:meth:`PathLine._seam`). Hops that are elided from the middle break the ribbon and do not join it. The mark is bare on the page, between a closing point and the notch of the next chip @@ -126,8 +127,8 @@ POWERLINE_SEP = "\ue0b0" #: The thin right-pointing chevron (U+E0B1). It is the outline sibling of the solid point, #: in the same core set. It is powerline's own mark for a join *inside* one colour. It #: draws the seam between two chips whose fills the eye cannot tell apart -#: (:meth:`PathLine._seam`). It is the previous fill, shaded, and drawn on the next chip, -#: where a solid point disappears. +#: (:meth:`PathLine._seam`). It is drawn on the next chip, where a solid point disappears, +#: in a colour halfway between the label and the fill of the previous chip. POWERLINE_THIN = "\ue0b1" #: The rounded caps (U+E0B6 opening, U+E0B4 closing) that finish the two outer ends of a @@ -1179,16 +1180,17 @@ class PathLine: equality, and it is not a gap of hue. There the seam is the **thin** chevron, :data:`POWERLINE_THIN`. It is drawn on the - fill ahead, in the colour of the label of the previous chip. It is powerline's - own mark for a join inside one colour, and the chip to which it belongs draws a line - on itself. Thus the ribbon continues without a break, and nothing on it is a colour - that is not a colour of a chip. Before, the solid point that was drawn bare cut a - wedge of page out of the route here. (A run of near hues read as dashes, and on a - light terminal the wedge was a hole.) Then the thin chevron was the previous fill, - one step darker in lightness (JP, 2026-09-16). When the label became the hue of the - node on a darker fill of itself (2026-10-06), the label colour became the line. It is - the light half of the same pair, so it is visible on each fill, and it is still the - own colour of the chip. In both cases the seam is one cell. + fill ahead. It is powerline's own mark for a join inside one colour, and the chip to + which it belongs draws a line on itself. Thus the ribbon continues without a break, + and the line comes from the two colours of the chip behind it. Before, the solid + point that was drawn bare cut a wedge of page out of the route here. (A run of near + hues read as dashes, and on a light terminal the wedge was a hole.) Then the thin + chevron was the previous fill, one step darker in lightness (JP, 2026-09-16). When + the label became the hue of the node on a darker fill of itself (2026-10-06), the + label colour became the line. Now the line is halfway between the label and the + fill of the previous chip (JP, 2026-10-29), so it is softer than the label and + still visible on the fill. On the 16-colour console, it is still the label + (:func:`_slot_seam`). In all cases the seam is one cell. Args: before: The colours of the previous chip. The point is drawn in its fill. @@ -1198,7 +1200,7 @@ class PathLine: The single styled cell of the seam. """ if _fills_blur(before.fill, after.fill): - return Text(POWERLINE_THIN, style=f"{_FLAT}{before.ink} on {after.fill}") + return Text(POWERLINE_THIN, style=f"{_FLAT}{_seam_line(before)} on {after.fill}") return Text(POWERLINE_SEP, style=f"{_FLAT}{before.fill} on {after.fill}") @staticmethod @@ -1335,9 +1337,30 @@ def _slot_colours(hop: PathHop) -> _ChipColours: return _ChipColours(DIM_TWIN[ink], ink, ink) -#: The colours of a chip, and the two prefixes of the chip styles. MeshTerm binds them when -#: the platform switches (:func:`_bind_chips`). +def _spectrum_seam(colours: _ChipColours) -> str: + """The line of a thin seam on a truecolor terminal: halfway between label and fill. + + The halfway point is in OKLab (:func:`~meshterm.ui.oklab.midpoint`), so the line is + halfway to the eye. Refer to :meth:`PathLine._seam`. + """ + return oklab.midpoint(colours.ink, colours.fill) + + +def _slot_seam(colours: _ChipColours) -> str: + """The line of a thin seam on the 16-colour console: the label. + + The console has no colour between a bright slot and its dim twin. The nearest slot to + the halfway point is the label for most hues, but not for all of them. For yellow on + brown, it is bright red. For white on light grey (a keyless chip), it is the light grey + of the fill, on which the line disappears. The label is correct for each chip. + """ + return colours.ink + + +#: The colours of a chip, the line of a thin seam, and the two prefixes of the chip styles. +#: MeshTerm binds them when the platform switches (:func:`_bind_chips`). _colours_of: Callable[[PathHop], _ChipColours] = _spectrum_colours +_seam_line: Callable[[_ChipColours], str] = _spectrum_seam #: The weight of a chip label: ``bold`` on a truecolor terminal. _WEIGHT = "bold " #: The prefix of each other chip style: empty on a truecolor terminal. @@ -1353,11 +1376,12 @@ def _bind_chips(platform: Platform) -> None: to its bright twin. For this reason each chip style there says ``not bold``, and a label gets no weight. Its bright slot is its emphasis. """ - global _colours_of, _WEIGHT, _FLAT + global _colours_of, _seam_line, _WEIGHT, _FLAT if platform.truecolor: - _colours_of, _WEIGHT, _FLAT = _spectrum_colours, "bold ", "" + _colours_of, _seam_line, _WEIGHT, _FLAT = _spectrum_colours, _spectrum_seam, "bold ", "" else: - _colours_of, _WEIGHT, _FLAT = _slot_colours, "not bold ", "not bold " + _colours_of, _seam_line = _slot_colours, _slot_seam + _WEIGHT, _FLAT = "not bold ", "not bold " def _shorten(value: str, hash_bytes: int | None) -> str: diff --git a/tests/test_oklab.py b/tests/test_oklab.py index 532db4b..c8788d1 100644 --- a/tests/test_oklab.py +++ b/tests/test_oklab.py @@ -80,6 +80,21 @@ def test_fitted_lowers_chroma_alone_and_keeps_near_hues_apart() -> None: assert abs(after[1]) < abs(before[1]) # less chroma +def test_midpoint_is_halfway_to_the_eye() -> None: + """The midpoint is equally far from the two colours, and half as far as they are apart. + + The midpoint of black and white has ``L`` 0.5. The midpoint of a colour with itself is + the same colour. + """ + assert oklab.from_hex(oklab.midpoint("#000000", "#ffffff"))[0] == pytest.approx(0.5, abs=0.01) + assert oklab.midpoint("#f25555", "#f25555") == "#f25555" + label, fill = "#55f255", _fill("4c") + middle = oklab.midpoint(label, fill) + half = oklab.distance(label, fill) / 2 + assert oklab.distance(middle, label) == pytest.approx(half, rel=0.05) + assert oklab.distance(middle, fill) == pytest.approx(half, rel=0.05) + + def test_from_hex_rejects_anything_but_six_digits() -> None: """Six hex digits are accepted, and the ``#`` and the case are optional. diff --git a/tests/test_pathline.py b/tests/test_pathline.py index 502e3f3..445a9bc 100644 --- a/tests/test_pathline.py +++ b/tests/test_pathline.py @@ -301,8 +301,9 @@ def test_picocalc_seams_on_one_colour_and_the_composer_slot(picocalc: None) -> N """Two chips of one colour join on a thin chevron in the hue. The slot is a break. The thin chevron is the bright twin of the fill: the colour of the label on the chip. - The slot of the composer has no white background on the console. Thus it is a white - ``+`` on the page, and the chips on each side close on a point and open on a notch. + The console has no colour halfway between the two. The slot of the composer has no + white background on the console. Thus it is a white ``+`` on the page, and the chips + on each side close on a point and open on a notch. """ same = PathLine([PathHop("Mill", key="1a"), PathHop("Tower", key="20")]).text() seam = same.plain.index(POWERLINE_THIN) @@ -858,14 +859,14 @@ def _seams(*hops: PathHop) -> list[tuple[str, str]]: def test_a_seam_between_two_of_one_colour_is_the_thin_chevron_in_its_label() -> None: - """Where two chips have the same fill, the seam is the thin chevron in the label colour. + """Where two chips have the same fill, the seam is the thin chevron, softer than the label. The interlock cannot draw a solid point in its own background. Thus MeshTerm draws the join *on* the shared fill instead (powerline's own mark for a join inside one - colour), and the ribbon continues without a break. Its colour is the label of the - previous chip. It is the light half of the chip's own pair, so it is visible on the - fill, and nothing on the line has a colour that is not a colour of a chip. The faded - slate draws it in its muted text. + colour), and the ribbon continues without a break. Its colour is halfway between the + label and the fill of the previous chip (JP, 2026-10-29). Thus it comes from the + chip's own pair, and it is softer than the label. The faded slate draws it halfway + between its muted text and its fill. This is not a rare accident. A mirrored return leg is a run of hops that are identically faded, by construction, and a stretch of keyless hops has one grey. In both cases the @@ -874,7 +875,10 @@ def test_a_seam_between_two_of_one_colour_is_the_thin_chevron_in_its_label() -> """ hue = _style_hex(node_style("aa")) glyph, style = _seams(PathHop("A", key="aa"), PathHop("B", key="aa"))[0] - assert (glyph, style) == (POWERLINE_THIN, f"{hue} on {_fill('aa')}") + line = oklab.midpoint(hue, _fill("aa")) + assert (glyph, style) == (POWERLINE_THIN, f"{line} on {_fill('aa')}") + to_label, to_fill = oklab.distance(line, hue), oklab.distance(line, _fill("aa")) + assert to_label == pytest.approx(to_fill, rel=0.05) and to_fill > SEAM_BLUR assert _seams(PathHop("A", key="aa"), PathHop("B", key="77"))[0] == ( POWERLINE_SEP, @@ -882,7 +886,7 @@ def test_a_seam_between_two_of_one_colour_is_the_thin_chevron_in_its_label() -> ) # a blend, one cell glyph, style = _seams(PathHop("A", dim=True), PathHop("B", dim=True))[0] - assert (glyph, style) == (POWERLINE_THIN, f"{_DIM_FG} on {_DIM_BG}") + assert (glyph, style) == (POWERLINE_THIN, f"{oklab.midpoint(_DIM_FG, _DIM_BG)} on {_DIM_BG}") def test_a_seam_blurs_by_perceived_distance_not_by_hue_gap() -> None: @@ -900,7 +904,8 @@ def test_a_seam_blurs_by_perceived_distance_not_by_hue_gap() -> None: assert green[0] == POWERLINE_THIN and red[0] == POWERLINE_SEP assert oklab.distance(_fill("4c"), _fill("5c")) < SEAM_BLUR assert oklab.distance(_fill("00"), _fill("10")) > SEAM_BLUR - assert green[1] == f"{_style_hex(node_style('4c'))} on {_fill('5c')}" + line = oklab.midpoint(_style_hex(node_style("4c")), _fill("4c")) + assert green[1] == f"{line} on {_fill('5c')}" wrapped = _seams(PathHop("A", key="fc"), PathHop("B", key="02"))[0] assert wrapped[0] == POWERLINE_THIN # neighbours across the seam of the wheel, also