ai2pixelart 0.1.0__tar.gz

ai2pixelart-0.1.0/LICENSE

@@ -0,0 +1,112 @@
+ai2pixelart — source code license
+
+The ai2pixelart source code is licensed under the PolyForm Noncommercial
+License 1.0.0 (full text below), together with the additional permission
+stated in "Output and production use" immediately below. In short: you may
+use, modify, and share the software for any noncommercial purpose, provided
+you keep the required notice; you may also run it to produce pixel art you
+sell; but you may not commercialize the software itself.
+
+The trained model weights are NOT covered by this license — they are
+distributed separately under Creative Commons Attribution-NonCommercial
+4.0 International (CC BY-NC 4.0), with the same output carve-out. See
+LICENSE-WEIGHTS.
+
+Required Notice: Copyright © 2026 Arne Kummerow — ai2pixelart
+
+----------------------------------------------------------------------
+
+## Additional permission: Output and production use
+
+As an exception to the noncommercial restriction in the PolyForm
+Noncommercial License 1.0.0 below, the licensor additionally grants you the
+right to run the ai2pixelart software (and the trained model weights) to
+produce pixel art and other images ("Output"), including in a commercial
+setting and including to produce Output that you sell or license. You own
+your Output; the licensor claims no rights in it, and it carries no
+noncommercial restriction or attribution requirement under these terms.
+
+What remains prohibited without a separate commercial license is
+commercializing the software or the model weights *themselves* — for
+example: selling or sublicensing them; offering their functionality to
+others as a paid, subscription, or advertising-supported product, service,
+platform, or API; or shipping them as a feature of a commercial product.
+
+In other words: making pixel art with the tool and using that art
+commercially is fine; turning the tool itself into a business is not.
+
+----------------------------------------------------------------------
+
+# PolyForm Noncommercial License 1.0.0
+
+<https://polyformproject.org/licenses/noncommercial/1.0.0>
+
+## Acceptance
+
+In order to get any license under these terms, you must agree to them as both strict obligations and conditions to all your licenses.
+
+## Copyright License
+
+The licensor grants you a copyright license for the software to do everything you might do with the software that would otherwise infringe the licensor's copyright in it for any permitted purpose.  However, you may only distribute the software according to [Distribution License](#distribution-license) and make changes or new works based on the software according to [Changes and New Works License](#changes-and-new-works-license).
+
+## Distribution License
+
+The licensor grants you an additional copyright license to distribute copies of the software.  Your license to distribute covers distributing the software with changes and new works permitted by [Changes and New Works License](#changes-and-new-works-license).
+
+## Notices
+
+You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms or the URL for them above, as well as copies of any plain-text lines beginning with `Required Notice:` that the licensor provided with the software.  For example:
+
+> Required Notice: Copyright Yoyodyne, Inc. (http://example.com)
+
+## Changes and New Works License
+
+The licensor grants you an additional copyright license to make changes and new works based on the software for any permitted purpose.
+
+## Patent License
+
+The licensor grants you a patent license for the software that covers patent claims the licensor can license, or becomes able to license, that you would infringe by using the software.
+
+## Noncommercial Purposes
+
+Any noncommercial purpose is a permitted purpose.
+
+## Personal Uses
+
+Personal use for research, experiment, and testing for the benefit of public knowledge, personal study, private entertainment, hobby projects, amateur pursuits, or religious observance, without any anticipated commercial application, is use for a permitted purpose.
+
+## Noncommercial Organizations
+
+Use by any charitable organization, educational institution, public research organization, public safety or health organization, environmental protection organization, or government institution is use for a permitted purpose regardless of the source of funding or obligations resulting from the funding.
+
+## Fair Use
+
+You may have "fair use" rights for the software under the law. These terms do not limit them.
+
+## No Other Rights
+
+These terms do not allow you to sublicense or transfer any of your licenses to anyone else, or prevent the licensor from granting licenses to anyone else.  These terms do not imply any other licenses.
+
+## Patent Defense
+
+If you make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
+
+## Violations
+
+The first time you are notified in writing that you have violated any of these terms, or done anything with the software not covered by your licenses, your licenses can nonetheless continue if you come into full compliance with these terms, and take practical steps to correct past violations, within 32 days of receiving notice.  Otherwise, all your licenses end immediately.
+
+## No Liability
+
+***As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.***
+
+## Definitions
+
+The **licensor** is the individual or entity offering these terms, and the **software** is the software the licensor makes available under these terms.
+
+**You** refers to the individual or entity agreeing to these terms.
+
+**Your company** is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization.  **Control** means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise.  Control can be direct or indirect.
+
+**Your licenses** are all the licenses granted to you for the software under these terms.
+
+**Use** means anything you do with the software requiring one of your licenses.

ai2pixelart-0.1.0/PKG-INFO

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: ai2pixelart
+Version: 0.1.0
+Summary: Turn AI-generated pseudo pixel art into pixel-perfect, palette-clean pixel art
+Author-email: Arne Kummerow <arne.kumero@gmail.com>
+License-Expression: PolyForm-Noncommercial-1.0.0
+Project-URL: Homepage, https://github.com/ArneKummerow/ai2pixelart
+Project-URL: Repository, https://github.com/ArneKummerow/ai2pixelart
+Project-URL: Model weights, https://huggingface.co/arnekummerow/ai2pixelart
+Keywords: pixel-art,image-restoration,image-to-image,retro,gamedev
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: scikit-image
+Requires-Dist: pillow
+Requires-Dist: click
+Provides-Extra: neural
+Requires-Dist: torch; extra == "neural"
+Requires-Dist: safetensors; extra == "neural"
+Requires-Dist: huggingface_hub; extra == "neural"
+Provides-Extra: gen
+Requires-Dist: ai2pixelart[neural]; extra == "gen"
+Requires-Dist: diffusers; extra == "gen"
+Requires-Dist: transformers; extra == "gen"
+Requires-Dist: accelerate; extra == "gen"
+Requires-Dist: peft; extra == "gen"
+Provides-Extra: dev
+Requires-Dist: ai2pixelart[neural]; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Dynamic: license-file
+
+# ai2pixelart
+
+Turn AI-generated *pseudo* pixel art (wobbly grids, mixed-color cells, way
+too many shades) into pixel-perfect, palette-clean pixel art — without
+losing the single-pixel details that carry the design.
+
+## Setup
+
+```bash
+pip install ai2pixelart              # classical cleaner only (no GPU, no torch)
+pip install "ai2pixelart[neural]"    # + run the trained networks
+pip install "ai2pixelart[gen]"       # + full data-engine / training stack
+```
+
+Or with conda for development:
+
+```bash
+conda env create -f environment.yml   # creates env "ai2pixelart"
+conda activate ai2pixelart
+pip install -e ".[dev]"
+```
+
+The classical "Simple" approach needs no GPU; the neural approaches need
+the `neural` extra and download their weights from the Hugging Face Hub
+([arnekummerow/ai2pixelart](https://huggingface.co/arnekummerow/ai2pixelart))
+automatically on first use (cached thereafter — `ai2pixelart models
+download` pre-fetches them for offline use).
+
+## Usage
+
+```bash
+ai2pixelart clean input.png -o out.png --preview-scale 8         # classical
+ai2pixelart clean input.png -o out.png --approach robust         # neural
+ai2pixelart clean input.png -o out.png --palette "#1e2234,#5ea740,#f0f0f0"
+ai2pixelart inspect my_images/            # no-ground-truth quality table
+ai2pixelart viewer my_images/             # interactive web workspace, port 8412
+```
+
+`--approach` is `simple` (classical, the default) or a neural model — a name
+under `runs/` (`robust`, `detail`) or a path to a `.safetensors`/`.ckpt`
+file. Run
+`ai2pixelart --help` to see the full command tree (`clean`, `viewer`,
+`inspect`, `eval`, `demo`, plus `data …` and `train …` for the pipeline).
+
+## How it works
+
+The classical pipeline ("Simple") detects the fake-pixel grid, extracts a
+palette, and votes each cell's color — deterministic, no GPU. The neural
+presets run the same grid/palette proposal, then a small U-Net assigns
+each cell a palette entry; it is structurally incapable of off-palette
+colors and carries learned priors (recovering pure 1-px details,
+collapsing shaded backgrounds) that no local method can. It was trained
+on pairs corrupted by the diffusion stack itself, so inverting AI
+rendering artifacts is exactly what it learned.
+
+Two checkpoints are maintained: **Neural Robust** (recommended default)
+and **Neural Detail** (best 1-px retention on very fine grids, the
+fallback when Robust over-corrects).
+
+## Limitations
+
+- Fake-pixel pitch below ~2 px is undetectable by construction — set the
+  pitch manually or use the granularity control.
+- One global grid per image: locally varying pitch is out of scope.
+- Colors missing from a forced palette cannot be assigned well by any
+  method.
+
+## Documentation
+
+- [docs/APPROACH.md](docs/APPROACH.md) — the method: classical pipeline,
+  neural design, training-data philosophy, when to use which preset.
+- [docs/VIEWER.md](docs/VIEWER.md) — the interactive workspace viewer.
+- [docs/IMPLEMENTATION.md](docs/IMPLEMENTATION.md) — module layout, data
+  engine, retraining recipes, server API.
+- [docs/DEVLOG.md](docs/DEVLOG.md) — the full iteration history: what was
+  tried, measured, rejected, and what's left as future work.
+
+## License
+
+**The pixel art you make with ai2pixelart is yours — sell it, ship it in a
+commercial game, whatever you like.** The noncommercial terms restrict the
+*tool*, not its output. Concretely:
+
+- ✅ Use it (even at a company) to produce pixel art, and use that art
+  commercially.
+- ✅ Modify and share the code and models for any noncommercial purpose,
+  keeping the credit notice.
+- ❌ Commercialize the tool itself — selling it, or offering its
+  functionality as a paid/subscription/ad-supported product, service,
+  platform, or API — needs a separate license.
+
+- **Source code** — [PolyForm Noncommercial License 1.0.0](LICENSE) + output carve-out.
+- **Trained model weights** — [CC BY-NC 4.0](LICENSE-WEIGHTS) + output carve-out.
+
+Credit: *ai2pixelart* © 2026 Arne Kummerow. These are source-available, not
+OSI "open source." To build something commercial *on the tool*, get in
+touch about a commercial license.

ai2pixelart-0.1.0/README.md

@@ -0,0 +1,97 @@
+# ai2pixelart
+
+Turn AI-generated *pseudo* pixel art (wobbly grids, mixed-color cells, way
+too many shades) into pixel-perfect, palette-clean pixel art — without
+losing the single-pixel details that carry the design.
+
+## Setup
+
+```bash
+pip install ai2pixelart              # classical cleaner only (no GPU, no torch)
+pip install "ai2pixelart[neural]"    # + run the trained networks
+pip install "ai2pixelart[gen]"       # + full data-engine / training stack
+```
+
+Or with conda for development:
+
+```bash
+conda env create -f environment.yml   # creates env "ai2pixelart"
+conda activate ai2pixelart
+pip install -e ".[dev]"
+```
+
+The classical "Simple" approach needs no GPU; the neural approaches need
+the `neural` extra and download their weights from the Hugging Face Hub
+([arnekummerow/ai2pixelart](https://huggingface.co/arnekummerow/ai2pixelart))
+automatically on first use (cached thereafter — `ai2pixelart models
+download` pre-fetches them for offline use).
+
+## Usage
+
+```bash
+ai2pixelart clean input.png -o out.png --preview-scale 8         # classical
+ai2pixelart clean input.png -o out.png --approach robust         # neural
+ai2pixelart clean input.png -o out.png --palette "#1e2234,#5ea740,#f0f0f0"
+ai2pixelart inspect my_images/            # no-ground-truth quality table
+ai2pixelart viewer my_images/             # interactive web workspace, port 8412
+```
+
+`--approach` is `simple` (classical, the default) or a neural model — a name
+under `runs/` (`robust`, `detail`) or a path to a `.safetensors`/`.ckpt`
+file. Run
+`ai2pixelart --help` to see the full command tree (`clean`, `viewer`,
+`inspect`, `eval`, `demo`, plus `data …` and `train …` for the pipeline).
+
+## How it works
+
+The classical pipeline ("Simple") detects the fake-pixel grid, extracts a
+palette, and votes each cell's color — deterministic, no GPU. The neural
+presets run the same grid/palette proposal, then a small U-Net assigns
+each cell a palette entry; it is structurally incapable of off-palette
+colors and carries learned priors (recovering pure 1-px details,
+collapsing shaded backgrounds) that no local method can. It was trained
+on pairs corrupted by the diffusion stack itself, so inverting AI
+rendering artifacts is exactly what it learned.
+
+Two checkpoints are maintained: **Neural Robust** (recommended default)
+and **Neural Detail** (best 1-px retention on very fine grids, the
+fallback when Robust over-corrects).
+
+## Limitations
+
+- Fake-pixel pitch below ~2 px is undetectable by construction — set the
+  pitch manually or use the granularity control.
+- One global grid per image: locally varying pitch is out of scope.
+- Colors missing from a forced palette cannot be assigned well by any
+  method.
+
+## Documentation
+
+- [docs/APPROACH.md](docs/APPROACH.md) — the method: classical pipeline,
+  neural design, training-data philosophy, when to use which preset.
+- [docs/VIEWER.md](docs/VIEWER.md) — the interactive workspace viewer.
+- [docs/IMPLEMENTATION.md](docs/IMPLEMENTATION.md) — module layout, data
+  engine, retraining recipes, server API.
+- [docs/DEVLOG.md](docs/DEVLOG.md) — the full iteration history: what was
+  tried, measured, rejected, and what's left as future work.
+
+## License
+
+**The pixel art you make with ai2pixelart is yours — sell it, ship it in a
+commercial game, whatever you like.** The noncommercial terms restrict the
+*tool*, not its output. Concretely:
+
+- ✅ Use it (even at a company) to produce pixel art, and use that art
+  commercially.
+- ✅ Modify and share the code and models for any noncommercial purpose,
+  keeping the credit notice.
+- ❌ Commercialize the tool itself — selling it, or offering its
+  functionality as a paid/subscription/ad-supported product, service,
+  platform, or API — needs a separate license.
+
+- **Source code** — [PolyForm Noncommercial License 1.0.0](LICENSE) + output carve-out.
+- **Trained model weights** — [CC BY-NC 4.0](LICENSE-WEIGHTS) + output carve-out.
+
+Credit: *ai2pixelart* © 2026 Arne Kummerow. These are source-available, not
+OSI "open source." To build something commercial *on the tool*, get in
+touch about a commercial license.

ai2pixelart-0.1.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ai2pixelart"
+version = "0.1.0"
+description = "Turn AI-generated pseudo pixel art into pixel-perfect, palette-clean pixel art"
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [{ name = "Arne Kummerow", email = "arne.kumero@gmail.com" }]
+# Source code only. The trained model weights are licensed separately under
+# CC BY-NC 4.0 (see LICENSE-WEIGHTS) and are not shipped in the wheel.
+license = "PolyForm-Noncommercial-1.0.0"
+license-files = ["LICENSE"]
+keywords = ["pixel-art", "image-restoration", "image-to-image", "retro", "gamedev"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: End Users/Desktop",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Operating System :: OS Independent",
+    "Topic :: Multimedia :: Graphics",
+    "Topic :: Scientific/Engineering :: Image Processing",
+]
+dependencies = [
+    "numpy",
+    "scipy",
+    "scikit-image",
+    "pillow",
+    "click",
+]
+
+[project.optional-dependencies]
+# run the trained networks (inference)
+neural = ["torch", "safetensors", "huggingface_hub"]
+# full data engine + training stack (implies neural)
+gen = ["ai2pixelart[neural]", "diffusers", "transformers", "accelerate", "peft"]
+dev = ["ai2pixelart[neural]", "pytest"]
+
+[project.urls]
+Homepage = "https://github.com/ArneKummerow/ai2pixelart"
+Repository = "https://github.com/ArneKummerow/ai2pixelart"
+"Model weights" = "https://huggingface.co/arnekummerow/ai2pixelart"
+
+[project.scripts]
+ai2pixelart = "ai2pixelart.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+ai2pixelart = ["viewer.html"]

ai2pixelart-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ai2pixelart-0.1.0/src/ai2pixelart/__init__.py

@@ -0,0 +1,5 @@
+"""ai2pixelart: turn AI-generated pseudo pixel art into pixel-perfect pixel art."""
+
+from ai2pixelart.pipeline import CleanResult, clean
+
+__all__ = ["clean", "CleanResult"]

ai2pixelart-0.1.0/src/ai2pixelart/autoqa.py

@@ -0,0 +1,147 @@
+"""No-ground-truth quality assessment of a cleanup result.
+
+Real AI images have no ground truth, so these metrics judge a CleanResult
+against the input itself, each targeting one observed failure mode:
+
+- grid: `boundary_snr` (gradient mass on cell edges vs interiors — is the
+  detected grid where the real fake-pixel boundaries are?) and
+  `pitch_consistency` (tile-wise re-estimation vs the global pitch — a
+  single global grid on mixed-pitch content is the pipeline's known
+  structural limitation, this measures how much an image violates it).
+- palette representation: `cell_fit_mean` / `cell_fit_p95` (ΔE between each
+  sampled cell color and the palette entry it received — high values mean
+  the palette is too small/flattened for this image, e.g. absorbed shade
+  families).
+- pixel-art flatness: `speckle_rate` (isolated single-cell index flips that
+  a detail-guarded mode filter would remove) and `shade_flicker` (adjacent
+  cells assigned near-duplicate entries <4 ΔE apart — soft-gradient banding
+  quantized into mottle; true pixel art places deliberately distinct colors
+  next to each other).
+- detail: `detail_survival` (sampled cells that are strong chromatic
+  outliers vs their 4-neighborhood must remain outliers in the output — the
+  1-px-detail promise, measured without ground truth).
+
+All ΔE are CIE76.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from ai2pixelart.grid import estimate_grid
+from ai2pixelart.palette import delta_e, rgb_to_lab
+from ai2pixelart.pipeline import CleanResult
+
+
+def boundary_snr(img: np.ndarray, result: CleanResult) -> float | None:
+    """Gradient mass on detected cell boundaries / interior average (per
+    axis, averaged). > 1.5 means the grid sits on real edges."""
+    if result.grid is None:
+        return None
+    ratios = []
+    for axis, ax_grid in ((0, result.grid.y), (1, result.grid.x)):
+        g = np.abs(np.diff(img.astype(np.float64), axis=axis)).sum(axis=2).mean(axis=1 - axis)
+        edge = np.round(ax_grid.edges[1:-1]).astype(int) - 1
+        edge = edge[(edge >= 0) & (edge < len(g))]
+        if not len(edge):
+            return None
+        on = np.zeros(len(g), dtype=bool)
+        on[edge] = True
+        if on.all() or not on.any():
+            return None
+        ratios.append(g[on].mean() / max(g[~on].mean(), 1e-9))
+    return float(np.mean(ratios))
+
+
+def pitch_consistency(img: np.ndarray, result: CleanResult, tiles: int = 3) -> float | None:
+    """Fraction of image tiles whose locally-estimated pitch agrees (±10%)
+    with the global grid, among tiles where estimation succeeds. Low values
+    flag mixed-pitch content (out of scope for the single global grid)."""
+    if result.grid is None:
+        return None
+    h, w = img.shape[:2]
+    if min(h, w) < tiles * 64:
+        return None
+    agree = total = 0
+    for ty in range(tiles):
+        for tx in range(tiles):
+            tile = img[ty * h // tiles : (ty + 1) * h // tiles, tx * w // tiles : (tx + 1) * w // tiles]
+            g = estimate_grid(tile)
+            if g is None:
+                continue
+            total += 1
+            ok_y = abs(g.y.pitch / result.grid.y.pitch - 1) <= 0.1
+            ok_x = abs(g.x.pitch / result.grid.x.pitch - 1) <= 0.1
+            agree += ok_y and ok_x
+    return float(agree / total) if total else None
+
+
+def cell_fit(result: CleanResult) -> tuple[float, float]:
+    """(mean, p95) ΔE between sampled cell colors and their palette entry."""
+    d = delta_e(rgb_to_lab(result.raw_cells), rgb_to_lab(result.palette[result.indices]))
+    return float(d.mean()), float(np.percentile(d, 95))
+
+
+def _neighbor_stacks(a: np.ndarray) -> np.ndarray:
+    """The 4-neighborhood of each entry, edge-padded: (4, H, W, ...)."""
+    pad = np.pad(a, [(1, 1), (1, 1)] + [(0, 0)] * (a.ndim - 2), mode="edge")
+    return np.stack([pad[:-2, 1:-1], pad[2:, 1:-1], pad[1:-1, :-2], pad[1:-1, 2:]])
+
+
+def speckle_rate(result: CleanResult, tol: float = 3.0) -> float:
+    """Fraction of cells that disagree with a >=5/8 neighborhood majority
+    while fitting the majority's entry within `tol` ΔE of their own — i.e.
+    quantization speckle a detail-guarded mode filter would remove."""
+    from ai2pixelart.pipeline import smooth_indices
+
+    smoothed = smooth_indices(result.indices, result.raw_cells, result.palette, tol=tol, passes=1)
+    return float((smoothed != result.indices).mean())
+
+
+def shade_flicker(result: CleanResult, close_de: float = 4.0) -> float:
+    """Fraction of adjacent cell pairs whose (different) palette entries are
+    nearly the same color — soft-gradient banding rendered as mottle."""
+    lab_pal = rgb_to_lab(result.palette)
+    idx = result.indices
+    pairs = flicker = 0
+    for a, b in ((idx[:, 1:], idx[:, :-1]), (idx[1:, :], idx[:-1, :])):
+        differ = a != b
+        close = delta_e(lab_pal[a], lab_pal[b]) < close_de
+        flicker += int((differ & close).sum())
+        pairs += differ.size
+    return float(flicker / max(pairs, 1))
+
+
+def detail_survival(result: CleanResult, outlier_de: float = 20.0) -> tuple[float, int]:
+    """(survival rate, n details): sampled cells whose color is far from all
+    4 neighbors (>= outlier_de) must stay distinct from all 4 neighbors in
+    the output."""
+    lab_raw = rgb_to_lab(result.raw_cells)
+    raw_min = delta_e(_neighbor_stacks(lab_raw), lab_raw[None]).min(axis=0)
+    details = raw_min >= outlier_de
+    n = int(details.sum())
+    if n == 0:
+        return 1.0, 0
+    lab_out = rgb_to_lab(result.palette)[result.indices]
+    out_min = delta_e(_neighbor_stacks(lab_out), lab_out[None]).min(axis=0)
+    return float((out_min[details] >= outlier_de * 0.5).mean()), n
+
+
+def assess(img: np.ndarray, result: CleanResult) -> dict:
+    """All no-GT metrics for one cleanup run."""
+    fit_mean, fit_p95 = cell_fit(result)
+    survival, n_details = detail_survival(result)
+    return {
+        "boundary_snr": _r(boundary_snr(img, result)),
+        "pitch_consistency": _r(pitch_consistency(img, result)),
+        "cell_fit_mean": round(fit_mean, 2),
+        "cell_fit_p95": round(fit_p95, 2),
+        "speckle_rate": round(speckle_rate(result), 4),
+        "shade_flicker": round(shade_flicker(result), 4),
+        "detail_survival": round(survival, 3),
+        "n_details": n_details,
+    }
+
+
+def _r(v, nd: int = 2):
+    return None if v is None else round(v, nd)