fix(anatomy): V1-2.2 refuse zones without a usable interior

A polygon or path zone or trigger must fill a disc of 4 CSS px on the
320 x 568 preview under the layer's nonzero rule, stroke left out:
conservative widest-disc search on the flattened outline, caps and a
per-sheet budget, closed codes interior_too_small and
marker_interior_too_small. Browser probe on six projects.
This commit is contained in:
bchanot committed 2026-11-01 12:19:08 +01:00
1 parent de2dfb392e
commit 8dd2d78d38
18 files changed
+1852 -38

No files matched your search

+1
View File
@@ -3,6 +3,7 @@ crates/core/tests/oracles/
crates/core/tests/conformance/ crates/core/tests/conformance/
crates/core/tests/fixtures/ crates/core/tests/fixtures/
apps/app/tests/fixtures/goldens/ apps/app/tests/fixtures/goldens/
apps/app/e2e/fixtures/interior-probe.json
packages/core-wasm/types/ packages/core-wasm/types/
packages/core-wasm/pkg/ packages/core-wasm/pkg/
packages/core-wasm/pkg-proofs/ packages/core-wasm/pkg-proofs/
+219
View File
@@ -0,0 +1,219 @@
{
"generatedBy": "crates/core/tests/interior_probe.rs",
"frame": {
"width": 286,
"height": 310
},
"cases": [
{
"name": "square-6",
"accepted": true,
"codes": [],
"widest": {
"x": 43.0,
"y": 43.0,
"r": 3.0
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><polygon points=\"40,40 46,40 46,46 40,46\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></polygon></g></svg>"
},
{
"name": "flat-triangle",
"accepted": true,
"codes": [],
"widest": {
"x": 70.0,
"y": 42.287,
"r": 2.287
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><polygon points=\"40,40 100,40 70,44.6\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></polygon></g></svg>"
},
{
"name": "arc-disc-6",
"accepted": true,
"codes": [],
"widest": {
"x": 43.0,
"y": 50.0,
"r": 2.998
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><path d=\"M40 50a3 3 0 1 0 6 0a3 3 0 1 0 -6 0Z\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></path></g></svg>"
},
{
"name": "cubic-lens",
"accepted": true,
"codes": [],
"widest": {
"x": 59.999,
"y": 50.0,
"r": 4.498
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><path d=\"M40 50C50 44 70 44 80 50C70 56 50 56 40 50Z\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></path></g></svg>"
},
{
"name": "ell-3.6",
"accepted": true,
"codes": [],
"widest": {
"x": 42.109,
"y": 42.109,
"r": 2.109
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><polygon points=\"40,40 80,40 80,43.6 43.6,43.6 43.6,80 40,80\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></polygon></g></svg>"
},
{
"name": "pentagram-evenodd-root",
"accepted": true,
"codes": [],
"widest": {
"x": 59.999,
"y": 60.0,
"r": 3.09
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g fill-rule=\"evenodd\"><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><polygon points=\"60,50 65.87785252292473,68.09016994374947 50.489434837048464,56.90983005625053 69.51056516295154,56.90983005625053 54.12214747707527,68.09016994374947\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></polygon></g></svg>"
},
{
"name": "forth-and-back",
"accepted": false,
"codes": [
"annotation.geometry.interior_too_small"
],
"widest": null,
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><path d=\"M40 40L90 90L40 40\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></path></g></svg>"
},
{
"name": "square-twice-opposite",
"accepted": false,
"codes": [
"annotation.geometry.interior_too_small"
],
"widest": null,
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><path d=\"M40 40h40v40h-40zM40 40v40h40v-40z\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></path></g></svg>"
},
{
"name": "diagonal-sliver",
"accepted": false,
"codes": [
"annotation.geometry.interior_too_small"
],
"widest": {
"x": 89.507,
"y": 88.809,
"r": 0.493
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><polygon points=\"40,40 90,90 90,88.6\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></polygon></g></svg>"
},
{
"name": "cubic-there-and-back",
"accepted": false,
"codes": [
"annotation.geometry.interior_too_small"
],
"widest": null,
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><path d=\"M40 80C50 40 80 40 90 80C80 40 50 40 40 80Z\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></path></g></svg>"
},
{
"name": "arc-there-and-back",
"accepted": false,
"codes": [
"annotation.geometry.interior_too_small"
],
"widest": null,
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><path d=\"M40 80A25 25 0 0 1 90 80A25 25 0 0 0 40 80Z\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></path></g></svg>"
},
{
"name": "flat-ellipse-45",
"accepted": false,
"codes": [
"annotation.geometry.interior_too_small"
],
"widest": {
"x": 65.0,
"y": 65.0,
"r": 1.0
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><path d=\"M40 40A35 1 45 0 1 90 90A35 1 45 0 1 40 40Z\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></path></g></svg>"
},
{
"name": "ell-3.3",
"accepted": false,
"codes": [
"annotation.geometry.interior_too_small"
],
"widest": {
"x": 41.933,
"y": 41.933,
"r": 1.933
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><polygon points=\"40,40 80,40 80,43.3 43.3,43.3 43.3,80 40,80\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></polygon></g></svg>"
},
{
"name": "triangle-6.6",
"accepted": false,
"codes": [
"annotation.geometry.interior_too_small"
],
"widest": {
"x": 43.3,
"y": 43.811,
"r": 1.905
},
"svg": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" viewBox=\"0 0 286 310\"><g><path d=\"M0 0h1\"/></g><g data-layer=\"annotations\" data-view-id=\"main\"><polygon points=\"40,45.716 46.6,45.716 43.3,40\" fill=\"#888888\" stroke=\"#888888\" fill-opacity=\"0.3\" stroke-width=\"2\" pointer-events=\"all\" style=\"cursor:pointer\" data-anno-id=\"shape\" data-anno-kind=\"zone\" data-anno-lateral=\"unpaired\" data-anno-name-fr=\"Jarret\" data-anno-name-en=\"Jarret\"><title>Jarret / Jarret</title></polygon></g></svg>"
}
],
"equine": [
{
"id": "caudal",
"view": "main",
"widest": {
"x": 1692.151,
"y": 554.007,
"r": 17.95
}
},
{
"id": "sacral",
"view": "main",
"widest": {
"x": 1470.781,
"y": 505.112,
"r": 40.963
}
},
{
"id": "lumbar",
"view": "main",
"widest": {
"x": 1341.641,
"y": 510.702,
"r": 51.297
}
},
{
"id": "thoracic",
"view": "main",
"widest": {
"x": 872.953,
"y": 484.677,
"r": 41.579
}
},
{
"id": "cervical",
"view": "main",
"widest": {
"x": 521.605,
"y": 279.763,
"r": 44.126
}
},
{
"id": "head-trigger",
"view": "main",
"widest": {
"x": 341.041,
"y": 303.749,
"r": 105.59
}
}
]
}
+12
View File
@@ -0,0 +1,12 @@
<!doctype html>
<html lang="fr">
<head>
<meta charset="UTF-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
<title>Interior harness</title>
</head>
<body style="margin: 0">
<div id="root"></div>
<script type="module" src="./interior.ts"></script>
</body>
</html>
+33
View File
@@ -0,0 +1,33 @@
/**
* Test page for the interior rule in a real browser (e2e/ui/interior-clicks.spec.ts): the
* canvas the core composes for one probe case (e2e/fixtures/interior-probe.json, generated by
* crates/core/tests/interior_probe.rs) in the phone preview's 286 × 310 box, inserted as the
* editor inserts it (DOMParser, importNode), every click on a marker recorded. Served by the
* Vite dev server only (`/e2e/harness/interior.html?case=`); the build never ships it.
*/
import probe from '../fixtures/interior-probe.json'
const name = new URLSearchParams(location.search).get('case')
const found = probe.cases.find((c) => c.name === name)
if (!found) throw new Error(`no probe case ${String(name)}`)
const root = document.getElementById('root') as HTMLElement
const clicks = document.createElement('output')
clicks.dataset.testid = 'clicks'
clicks.style.cssText = 'display:block;height:24px;overflow:hidden'
const box = document.createElement('div')
box.dataset.testid = 'preview'
box.style.cssText = `width:${probe.frame.width}px;height:${probe.frame.height}px`
const parsed = new DOMParser().parseFromString(found.svg, 'image/svg+xml')
const svg = document.importNode(
parsed.documentElement,
true,
) as unknown as SVGSVGElement
svg.style.cssText = 'display:block;width:100%;height:100%'
box.append(svg)
root.append(clicks, box)
box.addEventListener('click', (event) => {
const marker = (event.target as Element).closest('[data-anno-id]')
const id = marker?.getAttribute('data-anno-id')
if (id) clicks.textContent = `${clicks.textContent ?? ''} ${id}`.trim()
})
+3 -2
View File
@@ -41,13 +41,14 @@ export const PROJECTS: Project[] = [
] ]
/** /**
* The canvas click proof (V1-2.2, e2e/ui/canvas-clicks.spec.ts) also runs on Firefox and * The canvas click proofs (V1-2.2, e2e/ui/canvas-clicks.spec.ts and interior-clicks.spec.ts)
* also run on Firefox and
* WebKit, desktop, and on the WebKit phone, when the pinned engine is installed, and on a * WebKit, desktop, and on the WebKit phone, when the pinned engine is installed, and on a
* 320 px Chromium phone * 320 px Chromium phone
* (`playwright install firefox webkit`, no sudo, never `--with-deps`). A missing engine is * (`playwright install firefox webkit`, no sudo, never `--with-deps`). A missing engine is
* named in the run's output, never passed silently. * named in the run's output, never passed silently.
*/ */
const CANVAS_CLICKS = /canvas-clicks\.spec\.ts$/ const CANVAS_CLICKS = /(canvas|interior)-clicks\.spec\.ts$/
function installed(name: string, executable: string): boolean { function installed(name: string, executable: string): boolean {
const present = existsSync(executable) const present = existsSync(executable)
+295
View File
@@ -0,0 +1,295 @@
import { expect, test } from '../support/browser'
import type { Page } from '@playwright/test'
import probe from '../fixtures/interior-probe.json'
// Owner brief « V1-2.2 : fermeture du dernier MEDIUM » (2026-11-01): a zone or a trigger drawn
// as a polygon or a path must fill a disc of 4 CSS px on the phone preview, its stroke left
// out. The core's verdict (e2e/fixtures/interior-probe.json, crates/core/tests/interior_probe.rs)
// against the browser's own hit test, in the preview's 286 × 310 box (one unit per CSS px):
// an accepted shape takes real presses in the disc the core found and its fill alone holds a
// 4 px disc; a refused one fills none. Then the equine draft's zones, in the editor canvas.
// Run on Chromium, Firefox and WebKit when installed.
type Point = { x: number; y: number }
type Disc = { x: number; y: number; r: number }
/** The threshold: a disc of 4 CSS px across. */
const MIN_RADIUS_PX = 2
/** The browser's mask is sampled every quarter pixel: its radius is within that of the fill. */
const MASK_STEP_PX = 0.25
async function press(page: Page, at: Point, touch: boolean) {
if (touch) await page.touchscreen.tap(at.x, at.y)
else await page.mouse.click(at.x, at.y)
}
async function recorded(page: Page): Promise<string[]> {
const text = (await page.getByTestId('clicks').textContent()) ?? ''
return text.split(' ').filter(Boolean)
}
async function clickRecords(page: Page, at: Point, touch: boolean) {
const before = (await recorded(page)).length
await press(page, at, touch)
await page.waitForTimeout(50)
return (await recorded(page)).slice(before)
}
test.describe('interior clicks', () => {
for (const c of probe.cases) {
test(`${c.accepted ? 'accepted' : 'refused'}: ${c.name}`, async ({
page,
}, info) => {
await page.goto(`/e2e/harness/interior.html?case=${c.name}`)
await expect(page.locator('[data-anno-id="shape"]')).toBeAttached()
const browser = await page.evaluate(widestFill, MASK_STEP_PX)
if (c.widest) {
// The core never claims more than the browser fills (it may claim less: its disc
// crosses no edge, where a nonzero fill may run on past one).
expect(browser.r, JSON.stringify(browser)).toBeGreaterThan(
c.widest.r - 0.5,
)
}
if (!c.accepted) {
expect(browser.r, JSON.stringify(browser)).toBeLessThan(MIN_RADIUS_PX)
return
}
if (!c.widest) throw new Error(`${c.name} accepted without a disc`)
expect(browser.r).toBeGreaterThanOrEqual(MIN_RADIUS_PX)
const disc = c.widest
for (const fillOnly of [true, false]) {
const ring = await page.evaluate(ringHits, { disc, fillOnly })
expect(ring, `fillOnly ${String(fillOnly)}`).toEqual({
missed: [],
covered: 0,
})
}
const centre = await page.evaluate(toScreen, { x: disc.x, y: disc.y })
const touch = info.project.use.hasTouch === true
expect(await clickRecords(page, centre, touch)).toEqual(['shape'])
})
}
test('every equine zone holds the disc the core found and takes a real press', async ({
page,
}, info) => {
await page.goto('/e2e/harness/canvas.html')
await expect(
page.locator('[data-testid="anatomy-canvas"] [data-anno-id="caudal"]'),
).toBeAttached()
const touch = info.project.use.hasTouch === true
for (const zone of probe.equine) {
if (!zone.widest) throw new Error(`${zone.id} without a disc`)
const disc = zone.widest
// A point painted over the zone takes its taps (« the visible wins »): the samples under
// a visible disc are left out, at most a quarter of them.
const { missed, covered } = await page.evaluate(ringHits, {
disc,
fillOnly: false,
id: zone.id,
clearOfDiscs: true,
})
expect(missed, zone.id).toEqual([])
expect(covered, zone.id).toBeLessThanOrEqual(8)
// Chromium's touch adjustment gives a point the taps up to about 10 px around its disc
// (measured 2026-11-01): the real press goes where the zone's fill lies farthest from
// every disc, inside its edges.
const at = await page.evaluate(clearestFill, { id: zone.id, disc })
expect(await clickRecords(page, at, touch), zone.id).toEqual([zone.id])
}
})
})
/**
* In the page: the point of the shape's fill, on a half CSS px grid, its own on the hit test and
* inside its edges by 2 px or 60 % of the core's disc radius if less (the caudal zone's disc is
* 4.95 px across at 320), farthest from every visible disc.
*/
function clearestFill(args: { id: string; disc: Disc }): Point {
const { id, disc } = args
const svg = document.querySelector(
'[data-testid="anatomy-canvas"] svg',
) as SVGSVGElement
const ctm = svg.getScreenCTM()
if (!ctm) throw new Error('no CTM')
const shape = svg.querySelector(
`[data-anno-id="${id}"]`,
) as SVGGeometryElement
const twins = (
Array.from(
svg.querySelectorAll('circle[pointer-events="visiblePainted"]'),
) as SVGCircleElement[]
).map((t) => ({
centre: new DOMPoint(
t.cx.baseVal.value,
t.cy.baseVal.value,
).matrixTransform(ctm),
r: t.r.baseVal.value * ctm.a,
}))
const inverse = ctm.inverse()
const filled = (x: number, y: number) =>
shape.isPointInFill(new DOMPoint(x, y).matrixTransform(inverse))
const margin = Math.min(2, 0.6 * disc.r * ctm.a)
const box = shape.getBoundingClientRect()
let best = { x: 0, y: 0, d: -1 }
for (let x = Math.ceil(box.left); x <= box.right; x += 0.5) {
for (let y = Math.ceil(box.top); y <= box.bottom; y += 0.5) {
const steps = [-margin, 0, margin]
const inside = steps.every((dx) =>
steps.every((dy) => filled(x + dx, y + dy)),
)
if (!inside) continue
const hit = document.elementFromPoint(x, y)?.closest('[data-anno-id]')
if (hit?.getAttribute('data-anno-id') !== id) continue
const d = Math.min(
...twins.map((t) => Math.hypot(x - t.centre.x, y - t.centre.y) - t.r),
)
if (d > best.d) best = { x, y, d }
}
}
if (best.d < 0) throw new Error(`${id}: no fill clear of the discs`)
return { x: best.x, y: best.y }
}
/** In the page: a point of the layer's user space on screen. */
function toScreen(at: Point): Point {
const svg = document.querySelector('svg') as SVGSVGElement
const ctm = svg.getScreenCTM()
if (!ctm) throw new Error('no CTM')
const p = new DOMPoint(at.x, at.y).matrixTransform(ctm)
return { x: p.x, y: p.y }
}
/**
* In the page: the browser's hit test at the disc's centre and 32 points at 90 % of its radius.
* With `fillOnly` the shape takes `pointer-events="fill"` meanwhile, its stroke out of the test;
* with `clearOfDiscs` the points within a visible disc (its stroke and half a pixel included)
* are counted apart. Answers the points that hit another element, and the points left out.
*/
function ringHits(args: {
disc: Disc
fillOnly: boolean
id?: string
clearOfDiscs?: boolean
}): { missed: string[]; covered: number } {
const { disc, fillOnly } = args
const id = args.id ?? 'shape'
const svg = document.querySelector('svg') as SVGSVGElement
const ctm = svg.getScreenCTM()
if (!ctm) throw new Error('no CTM')
const shapes = Array.from(svg.querySelectorAll(`[data-anno-id="${id}"]`))
const kept = shapes.map((s) => s.getAttribute('pointer-events'))
if (fillOnly) shapes.forEach((s) => s.setAttribute('pointer-events', 'fill'))
const reach = disc.r * 0.9
const points: Point[] = [{ x: disc.x, y: disc.y }]
for (let k = 0; k < 32; k++) {
const a = (k * 2 * Math.PI) / 32
points.push({
x: disc.x + reach * Math.cos(a),
y: disc.y + reach * Math.sin(a),
})
}
const twins = Array.from(
svg.querySelectorAll('circle[pointer-events="visiblePainted"]'),
) as SVGCircleElement[]
const underDisc = (at: Point) =>
twins.some(
(t) =>
Math.hypot(at.x - t.cx.baseVal.value, at.y - t.cy.baseVal.value) <=
t.r.baseVal.value + 0.75 + 0.5 / ctm.a,
)
const missed: string[] = []
let covered = 0
for (const at of points) {
if (args.clearOfDiscs && underDisc(at)) {
covered++
continue
}
const p = new DOMPoint(at.x, at.y).matrixTransform(ctm)
const hit = document
.elementFromPoint(p.x, p.y)
?.closest('[data-anno-id]')
?.getAttribute('data-anno-id')
if (hit !== id)
missed.push(`${at.x.toFixed(2)},${at.y.toFixed(2)}: ${String(hit)}`)
}
shapes.forEach((s, i) => {
const value = kept[i]
if (value === null || value === undefined)
s.removeAttribute('pointer-events')
else s.setAttribute('pointer-events', value)
})
return { missed, covered }
}
/**
* In the page: the widest disc of the shape's fill as the browser hits it (`pointer-events`
* `fill`, the stroke out), from a mask sampled every `step` CSS px over its box and 3 px around
* it, by an exact Euclidean distance transform (Felzenszwalb and Huttenlocher). The radius is
* the distance to the nearest sample outside the fill, less half a step.
*/
function widestFill(step: number): Disc {
const svg = document.querySelector('svg') as SVGSVGElement
const shape = svg.querySelector(
'[data-anno-id="shape"]',
) as SVGGraphicsElement
const kept = shape.getAttribute('pointer-events')
shape.setAttribute('pointer-events', 'fill')
const box = shape.getBoundingClientRect()
const x0 = box.left - 3
const y0 = box.top - 3
const w = Math.ceil((box.width + 6) / step) + 1
const h = Math.ceil((box.height + 6) / step) + 1
const far = 1e20
const grid = new Float64Array(w * h)
for (let j = 0; j < h; j++) {
for (let i = 0; i < w; i++) {
const hit = document.elementFromPoint(x0 + i * step, y0 + j * step)
grid[j * w + i] = hit === shape ? far : 0
}
}
if (kept === null) shape.removeAttribute('pointer-events')
else shape.setAttribute('pointer-events', kept)
const line = (f: Float64Array): Float64Array => {
const n = f.length
const d = new Float64Array(n)
const v = new Int32Array(n)
const z = new Float64Array(n + 1)
let k = 0
v[0] = 0
z[0] = -Infinity
z[1] = Infinity
for (let q = 1; q < n; q++) {
let s = (f[q] + q * q - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k])
while (s <= z[k]) {
k--
s = (f[q] + q * q - (f[v[k]] + v[k] * v[k])) / (2 * q - 2 * v[k])
}
k++
v[k] = q
z[k] = s
z[k + 1] = Infinity
}
k = 0
for (let q = 0; q < n; q++) {
while (z[k + 1] < q) k++
d[q] = (q - v[k]) ** 2 + f[v[k]]
}
return d
}
for (let i = 0; i < w; i++) {
const column = new Float64Array(h)
for (let j = 0; j < h; j++) column[j] = grid[j * w + i]
const done = line(column)
for (let j = 0; j < h; j++) grid[j * w + i] = done[j]
}
let best = { x: 0, y: 0, r: 0 }
for (let j = 0; j < h; j++) {
const done = line(grid.subarray(j * w, (j + 1) * w).slice())
for (let i = 0; i < w; i++) {
const r = Math.sqrt(done[i]) * step - step / 2
if (r > best.r) best = { x: x0 + i * step, y: y0 + j * step, r }
}
}
return best
}
+51 -10
View File
@@ -16,7 +16,11 @@
//! about `|v| × 2⁻²⁴` and, measured against the frame, grows with the ratio of the frame's //! about `|v| × 2⁻²⁴` and, measured against the frame, grows with the ratio of the frame's
//! farthest edge to its span. And each annotation must show at least `MIN_VISIBLE_PX` on the //! farthest edge to its span. And each annotation must show at least `MIN_VISIBLE_PX` on the
//! smallest preview the product supports, measured on the shape the layer paints. //! smallest preview the product supports, measured on the shape the layer paints.
//!
//! Owner brief 2026-11-01 (the last MEDIUM, zone without interior): a polygon or a path must
//! also fill a disc of `MIN_VISIBLE_PX` on that preview (`interior`), its stroke left out.
use super::interior::{Budget, LAYER_FILL_RULE, Search, geometry_outline, widest_disc};
use super::layer::{find_view, twin_radius}; use super::layer::{find_view, twin_radius};
use super::path::{Bounds, number_list, path_bounds}; use super::path::{Bounds, number_list, path_bounds};
use super::svg::Element; use super::svg::Element;
@@ -61,6 +65,9 @@ pub const DETAIL_PREVIEW_PX: (f64, f64) = (254.0, 191.0);
/// The smallest visible size of an annotation on that preview (owner decision 2026-11-01): a /// The smallest visible size of an annotation on that preview (owner decision 2026-11-01): a
/// point's visible disc, a filled shape's smaller side. The equine junctions show 4.97 px. /// point's visible disc, a filled shape's smaller side. The equine junctions show 4.97 px.
pub const MIN_VISIBLE_PX: f64 = 4.0; pub const MIN_VISIBLE_PX: f64 = 4.0;
/// How far a chord may depart from its curve, and the step below which the interior search
/// cuts no cell, on that preview: far below a device pixel, taken off the measure.
pub const INTERIOR_TOLERANCE_PX: f64 = 0.05;
impl Frame { impl Frame {
fn from_numbers(min_x: f64, min_y: f64, width: f64, height: f64) -> Option<Self> { fn from_numbers(min_x: f64, min_y: f64, width: f64, height: f64) -> Option<Self> {
@@ -138,6 +145,12 @@ pub enum Placement {
Unreadable, Unreadable,
/// In frame, but smaller than `MIN_VISIBLE_PX` on the smallest preview. /// In frame, but smaller than `MIN_VISIBLE_PX` on the smallest preview.
TooSmall, TooSmall,
/// A polygon or a path in frame whose fill holds no disc of `MIN_VISIBLE_PX` on the smallest
/// preview.
InteriorTooSmall,
/// A polygon or a path the interior measure cannot afford: past
/// `interior::MAX_OUTLINE_VERTICES`, or the sheet's `interior::MAX_INTERIOR_WORK` spent.
InteriorUnmeasured,
} }
/// The size an annotation shows, in frame units: what the layer paints. A point's (or a circle /// The size an annotation shows, in frame units: what the layer paints. A point's (or a circle
@@ -190,26 +203,52 @@ fn placement_with_bounds(geometry: &Geometry, frame: &Frame) -> (Placement, Opti
} }
} }
/// The placement of `annotation` on its view's frame, its visible size on the smallest preview /// The placement of `annotation` on its view's frame, its visible size and its interior on the
/// included. /// smallest preview included, the interior measured within the sheet's `budget`.
pub fn annotation_placement(annotation: &Annotation, frame: &Frame, main_view: bool) -> Placement { pub fn annotation_placement(
annotation: &Annotation,
frame: &Frame,
main_view: bool,
budget: &mut Budget,
) -> Placement {
let Some(geometry) = geometry_of(annotation) else { let Some(geometry) = geometry_of(annotation) else {
return Placement::InFrame; return Placement::InFrame;
}; };
match placement_with_bounds(geometry, frame) { match placement_with_bounds(geometry, frame) {
(Placement::InFrame, Some(bounds)) => { (Placement::InFrame, Some(bounds)) => {
let shown = let scale = frame.preview_scale(main_view);
visible_size(annotation, geometry, &bounds) * frame.preview_scale(main_view); if visible_size(annotation, geometry, &bounds) * scale < MIN_VISIBLE_PX {
if shown >= MIN_VISIBLE_PX {
Placement::InFrame
} else {
Placement::TooSmall Placement::TooSmall
} else {
interior_placement(geometry, scale, budget)
} }
} }
(placement, _) => placement, (placement, _) => placement,
} }
} }
/// Whether the fill of a polygon or a path holds a disc of `MIN_VISIBLE_PX` at `scale` CSS px
/// per unit; a circle's disc is its own (path data the bounds read whole always has an outline).
fn interior_placement(geometry: &Geometry, scale: f64, budget: &mut Budget) -> Placement {
let tolerance = INTERIOR_TOLERANCE_PX / scale;
let Some(outline) = geometry_outline(geometry, tolerance) else {
return Placement::InFrame;
};
if !budget.affords(&outline) {
return Placement::InteriorUnmeasured;
}
let radius = MIN_VISIBLE_PX / 2.0 / scale;
let search = Search {
floor: radius,
enough: radius,
precision: tolerance,
};
match widest_disc(&outline, LAYER_FILL_RULE, &search, budget) {
Some(disc) if disc.radius >= radius => Placement::InFrame,
_ => Placement::InteriorTooSmall,
}
}
/// What the frame check found on one view. /// What the frame check found on one view.
#[derive(Debug, Clone, PartialEq, Eq)] #[derive(Debug, Clone, PartialEq, Eq)]
pub enum FrameFault { pub enum FrameFault {
@@ -229,6 +268,7 @@ pub fn frame_faults<'a>(
drawing_of: impl Fn(&str) -> Option<&'a Element>, drawing_of: impl Fn(&str) -> Option<&'a Element>,
) -> Vec<FrameFault> { ) -> Vec<FrameFault> {
let mut faults = Vec::new(); let mut faults = Vec::new();
let mut budget = Budget::default();
for (view_index, view) in document.views.iter().enumerate() { for (view_index, view) in document.views.iter().enumerate() {
// A repeated view id draws the first view of that id, as the composers find it. // A repeated view id draws the first view of that id, as the composers find it.
if !find_view(document, view.id()).is_some_and(|first| std::ptr::eq(first, view)) { if !find_view(document, view.id()).is_some_and(|first| std::ptr::eq(first, view)) {
@@ -242,7 +282,7 @@ pub fn frame_faults<'a>(
faults.push(FrameFault::NoFrame { view_index }); faults.push(FrameFault::NoFrame { view_index });
continue; continue;
}; };
faults.extend(annotation_faults(document, view, &frame)); faults.extend(annotation_faults(document, view, &frame, &mut budget));
} }
faults faults
} }
@@ -251,6 +291,7 @@ fn annotation_faults(
document: &AnatomicalSheetDocument, document: &AnatomicalSheetDocument,
view: &SheetView, view: &SheetView,
frame: &Frame, frame: &Frame,
budget: &mut Budget,
) -> Vec<FrameFault> { ) -> Vec<FrameFault> {
document document
.annotations .annotations
@@ -258,7 +299,7 @@ fn annotation_faults(
.enumerate() .enumerate()
.filter(|(_, a)| a.view_id() == view.id()) .filter(|(_, a)| a.view_id() == view.id())
.filter_map(|(annotation_index, annotation)| { .filter_map(|(annotation_index, annotation)| {
let placement = annotation_placement(annotation, frame, view.is_main()); let placement = annotation_placement(annotation, frame, view.is_main(), budget);
(placement != Placement::InFrame).then_some(FrameFault::Annotation { (placement != Placement::InFrame).then_some(FrameFault::Annotation {
annotation_index, annotation_index,
placement, placement,
+450
View File
@@ -0,0 +1,450 @@
//! The interior a tap can reach in a filled shape (owner brief « V1-2.2 : fermeture du dernier
//! MEDIUM », 2026-11-01). A zone or a trigger drawn as a polygon or a path passes the bounds rule
//! of `frame` with a large box and still selects nothing: a path drawn forth and back fills no
//! point (winding 0), a near-flat polygon fills a sliver. The layer's shapes take taps on their
//! fill and their 2-unit stroke; the stroke never counts here.
//!
//! The measure is the widest disc the fill holds, under the fill rule the layer paints with
//! (`LAYER_FILL_RULE`: the layer writes none, the composition root carries none, so `nonzero`).
//! It is conservative. A centre counts only when the fill rule puts it inside and every edge of
//! the outline, the closing edges included, is at least the radius away: the disc then crosses
//! no edge, so every point of it has the centre's winding number. Curves and arcs are cut into
//! chords (`path::path_outline`) and the chord deviation is taken off the radius. The search is
//! the polylabel subdivision (square cells, a cell's best possible centre is its centre's
//! distance plus its half diagonal, the most promising cell cut first), at most
//! `MAX_INTERIOR_CELLS` cells: deterministic, and what it has not shown counts as absent. One
//! budget (`Budget`, edge distances) bounds the work on a whole sheet: a shape it can no longer
//! afford is refused, never accepted.
use std::cmp::Ordering;
use std::collections::BinaryHeap;
use std::f64::consts::SQRT_2;
use super::path::{Outline, path_outline};
use crate::domain::sheet::Geometry;
/// How a point is inside a fill (SVG `fill-rule`).
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum FillRule {
NonZero,
EvenOdd,
}
/// The fill rule of the layer's shapes: the SVG initial value, as no `fill-rule` reaches them.
pub const LAYER_FILL_RULE: FillRule = FillRule::NonZero;
/// The largest number of outline vertices measured: past it the shape is refused (a hand-drawn
/// zone holds tens; the equine at most 17).
pub const MAX_OUTLINE_VERTICES: usize = 4096;
/// The largest number of cells the search evaluates.
pub const MAX_INTERIOR_CELLS: usize = 4096;
/// The edge distances the measure may compute on one sheet: `2²⁵`, about 0.35 s natively
/// (measured 2026-11-01: 8 192 edges × 4 096 cells), where the equine draft takes about 10⁵.
pub const MAX_INTERIOR_WORK: usize = 1 << 25;
/// The work left to the measure on one sheet.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Budget {
pub work: usize,
}
impl Default for Budget {
fn default() -> Self {
Self {
work: MAX_INTERIOR_WORK,
}
}
}
impl Budget {
/// The cells left for an outline of `edges` edges.
fn cells(&self, edges: usize) -> usize {
MAX_INTERIOR_CELLS.min(self.work / edges.max(1))
}
/// Whether the outline can still be measured: within the vertex cap, one cell affordable.
pub fn affords(&self, outline: &Outline) -> bool {
!outline.overflow && self.cells(edge_count(outline)) > 0
}
}
fn edge_count(outline: &Outline) -> usize {
outline.subpaths.iter().map(Vec::len).sum()
}
/// A disc inside the fill.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Disc {
pub centre: (f64, f64),
pub radius: f64,
}
/// What the search looks for, in user units: cells that cannot reach `floor` are dropped, the
/// search stops at a disc of `enough`, and no cell is cut below `precision`.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct Search {
pub floor: f64,
pub enough: f64,
pub precision: f64,
}
/// The fill outline of a polygon or a path, chords at most `tolerance` from the curves; `None`
/// for a circle (its disc is exact) and for path data a browser would not read whole.
pub fn geometry_outline(geometry: &Geometry, tolerance: f64) -> Option<Outline> {
match geometry {
Geometry::Circle(_) => None,
Geometry::Polygon(p) => Some(Outline {
subpaths: vec![p.points.iter().map(|p| (p.0, p.1)).collect()],
deviation: 0.0,
overflow: p.points.len() > MAX_OUTLINE_VERTICES,
}),
Geometry::Path(path) => path_outline(&path.d, tolerance, MAX_OUTLINE_VERTICES),
}
}
/// The widest disc found inside the outline's fill under `rule`, its radius net of the chord
/// deviation, the work taken from `budget`; `None` when the search shows none.
pub fn widest_disc(
outline: &Outline,
rule: FillRule,
search: &Search,
budget: &mut Budget,
) -> Option<Disc> {
let edges = edge_count(outline);
let affordable = budget.cells(edges);
if affordable == 0 {
return None;
}
let mut points = outline.subpaths.iter().flatten();
let first = *points.next()?;
let (min, max) = points.fold((first, first), |(min, max), &(x, y)| {
((min.0.min(x), min.1.min(y)), (max.0.max(x), max.1.max(y)))
});
let half = (max.0 - min.0).max(max.1 - min.1) / 2.0;
let root = Cell::new(outline, rule, (min.0 + half, min.1 + half), half);
let mut best = root.disc();
let mut cells = BinaryHeap::from([root]);
let mut evaluated = 1;
while let Some(cell) = cells.pop() {
let widest = best.map_or(0.0, |disc| disc.radius);
// The heap gives the cell of greatest reach: when it cannot do better, none can.
if widest >= search.enough
|| cell.reach() < search.floor
|| cell.reach() <= widest + search.precision
|| evaluated + 4 > affordable
{
break;
}
if cell.half * SQRT_2 <= search.precision {
continue;
}
let quarter = cell.half / 2.0;
for (dx, dy) in [(-1.0, -1.0), (1.0, -1.0), (-1.0, 1.0), (1.0, 1.0)] {
let centre = (cell.centre.0 + dx * quarter, cell.centre.1 + dy * quarter);
let child = Cell::new(outline, rule, centre, quarter);
if child.radius > best.map_or(0.0, |disc| disc.radius) {
best = child.disc();
}
cells.push(child);
}
evaluated += 4;
}
budget.work -= evaluated * edges;
best
}
/// A square cell of the search: its centre's radius and its half side.
struct Cell {
centre: (f64, f64),
half: f64,
radius: f64,
}
impl Cell {
fn new(outline: &Outline, rule: FillRule, centre: (f64, f64), half: f64) -> Self {
let radius = clearance(outline, rule, centre) - outline.deviation;
Self {
centre,
half,
radius,
}
}
/// The widest radius a centre inside the cell could have.
fn reach(&self) -> f64 {
self.radius + self.half * SQRT_2
}
fn disc(&self) -> Option<Disc> {
(self.radius > 0.0).then_some(Disc {
centre: self.centre,
radius: self.radius,
})
}
}
impl Ord for Cell {
fn cmp(&self, other: &Self) -> Ordering {
self.reach().total_cmp(&other.reach())
}
}
impl PartialOrd for Cell {
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
Some(self.cmp(other))
}
}
impl PartialEq for Cell {
fn eq(&self, other: &Self) -> bool {
self.cmp(other) == Ordering::Equal
}
}
impl Eq for Cell {}
/// The distance from `point` to the nearest edge, negative when the fill leaves it out.
fn clearance(outline: &Outline, rule: FillRule, point: (f64, f64)) -> f64 {
let mut nearest = f64::INFINITY;
let mut winding = 0_i64;
for subpath in &outline.subpaths {
let closing = subpath.last().into_iter().chain(subpath.iter());
for (&a, &b) in closing.zip(subpath.iter()) {
nearest = nearest.min(segment_distance(point, a, b));
winding += crossing(point, a, b);
}
}
let inside = match rule {
FillRule::NonZero => winding != 0,
FillRule::EvenOdd => winding % 2 != 0,
};
if inside { nearest } else { -nearest }
}
/// +1 or −1 when the edge crosses the horizontal ray to the right of `point` upwards or
/// downwards, else 0.
fn crossing(point: (f64, f64), a: (f64, f64), b: (f64, f64)) -> i64 {
let side = (b.0 - a.0) * (point.1 - a.1) - (point.0 - a.0) * (b.1 - a.1);
if a.1 <= point.1 && point.1 < b.1 && side > 0.0 {
1
} else if b.1 <= point.1 && point.1 < a.1 && side < 0.0 {
-1
} else {
0
}
}
fn segment_distance(p: (f64, f64), a: (f64, f64), b: (f64, f64)) -> f64 {
let (dx, dy) = (b.0 - a.0, b.1 - a.1);
let length = dx * dx + dy * dy;
let t = if length > 0.0 {
(((p.0 - a.0) * dx + (p.1 - a.1) * dy) / length).clamp(0.0, 1.0)
} else {
0.0
};
(p.0 - a.0 - t * dx).hypot(p.1 - a.1 - t * dy)
}
#[cfg(test)]
#[allow(clippy::unwrap_used)]
mod tests {
use super::*;
const MEASURE: Search = Search {
floor: 0.0,
enough: f64::INFINITY,
precision: 1e-3,
};
fn polygon(points: &[(f64, f64)]) -> Outline {
Outline {
subpaths: vec![points.to_vec()],
..Outline::default()
}
}
fn widest(outline: &Outline, rule: FillRule) -> f64 {
measure(outline, rule).map_or(0.0, |d| d.radius)
}
fn measure(outline: &Outline, rule: FillRule) -> Option<Disc> {
widest_disc(outline, rule, &MEASURE, &mut Budget::default())
}
#[test]
fn a_square_holds_its_inscribed_disc() {
let square = polygon(&[(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0)]);
let r = widest(&square, FillRule::NonZero);
assert!((r - 5.0).abs() < 2e-3, "{r}");
}
/// A pentagram: its centre has winding 2, filled under nonzero, a hole under evenodd.
#[test]
fn the_fill_rule_decides_a_self_intersection() {
let star: Vec<(f64, f64)> = (0..5)
.map(|i| {
let angle =
std::f64::consts::FRAC_PI_2 + f64::from(i * 2) * std::f64::consts::TAU / 5.0;
(100.0 * angle.cos(), 100.0 * angle.sin())
})
.collect();
let star = polygon(&star);
let nonzero = widest(&star, FillRule::NonZero);
let evenodd = widest(&star, FillRule::EvenOdd);
// Conservative: the disc crosses no edge, so it stops at the inner pentagon's inscribed
// radius, 100 × cos 72° ≈ 30.9, where the fill itself reaches the concave corners at
// 38.2; under evenodd the centre is a hole and only a tip's disc remains.
assert!(
(nonzero - 100.0 * 72_f64.to_radians().cos()).abs() < 0.01,
"{nonzero}"
);
// A tip, an isosceles triangle of apex 36°: inscribed radius 16.31.
assert!((evenodd - 16.31).abs() < 0.01, "{evenodd}");
let centre = clearance(&star, FillRule::EvenOdd, (0.0, 0.0));
assert!(centre < 0.0, "the centre is a hole under evenodd");
}
#[test]
fn an_outline_drawn_forth_and_back_fills_nothing() {
let there_and_back = polygon(&[(0.0, 0.0), (50.0, 0.0), (50.0, 50.0), (50.0, 0.0)]);
for rule in [FillRule::NonZero, FillRule::EvenOdd] {
assert!(measure(&there_and_back, rule).is_none());
}
// Two opposite loops over the same square: winding 0 under nonzero, 2 even.
let square = [(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0)];
let mut reversed = square;
reversed.reverse();
let both = Outline {
subpaths: vec![square.to_vec(), reversed.to_vec()],
..Outline::default()
};
assert!(measure(&both, FillRule::NonZero).is_none());
assert!(measure(&both, FillRule::EvenOdd).is_none());
}
#[test]
fn the_deviation_is_taken_off() {
let mut square = polygon(&[(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0)]);
square.deviation = 1.0;
let r = widest(&square, FillRule::NonZero);
assert!((r - 4.0).abs() < 2e-3, "{r}");
}
#[test]
fn the_search_stops_at_enough_and_drops_cells_below_the_floor() {
let square = polygon(&[(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0)]);
let enough = Search {
floor: 2.0,
enough: 2.0,
precision: 1e-3,
};
let disc =
widest_disc(&square, FillRule::NonZero, &enough, &mut Budget::default()).unwrap();
assert!(disc.radius >= 2.0);
let out_of_reach = Search {
floor: 5.1,
enough: 5.1,
precision: 1e-3,
};
let disc = widest_disc(
&square,
FillRule::NonZero,
&out_of_reach,
&mut Budget::default(),
);
assert!(disc.is_none_or(|d| d.radius < 5.1));
}
/// The budget counts edge distances across shapes; a shape it cannot afford is not measured.
#[test]
fn the_budget_is_shared_and_spent() {
let square = polygon(&[(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0)]);
let mut budget = Budget { work: 4 * 9 };
assert!(budget.affords(&square));
let small = widest_disc(&square, FillRule::NonZero, &MEASURE, &mut budget);
assert!(small.is_some(), "the root cell finds the centre");
assert_eq!(budget.work, 0, "nine cells: the root and two cuts of four");
let mut spent = Budget { work: 3 };
assert!(!spent.affords(&square));
assert!(widest_disc(&square, FillRule::NonZero, &MEASURE, &mut spent).is_none());
let mut too_many = square.clone();
too_many.overflow = true;
assert!(!Budget::default().affords(&too_many));
}
#[test]
fn every_centre_found_holds_its_disc() {
let comb = polygon(&[
(0.0, 0.0),
(30.0, 0.0),
(30.0, 10.0),
(20.0, 10.0),
(20.0, 2.0),
(10.0, 2.0),
(10.0, 10.0),
(0.0, 10.0),
]);
let disc = measure(&comb, FillRule::NonZero).unwrap();
for i in 0..64 {
let angle = f64::from(i) * std::f64::consts::TAU / 64.0;
let at = (
disc.centre.0 + 0.999 * disc.radius * angle.cos(),
disc.centre.1 + 0.999 * disc.radius * angle.sin(),
);
assert!(clearance(&comb, FillRule::NonZero, at) > 0.0, "{at:?}");
}
assert!((disc.radius - 5.0).abs() < 2e-3, "{disc:?}");
}
/// A deterministic generator for the sampled comparisons.
struct Lcg(u64);
impl Lcg {
fn next(&mut self, low: f64, high: f64) -> f64 {
self.0 = self
.0
.wrapping_mul(6_364_136_223_846_793_005)
.wrapping_add(1_442_695_040_888_963_407);
low + (high - low) * ((self.0 >> 11) as f64 / (1_u64 << 53) as f64)
}
}
/// Random polygons, self-intersecting ones included, under both rules: the disc found never
/// beats a dense grid of centres by more than the grid's half diagonal, and every point of
/// its rim is filled.
#[test]
fn the_disc_found_is_never_wider_than_the_fill() {
let mut rng = Lcg(5);
for case in 0..60 {
let count = 3 + (case % 7);
let points: Vec<(f64, f64)> = (0..count)
.map(|_| (rng.next(0.0, 40.0), rng.next(0.0, 40.0)))
.collect();
let shape = polygon(&points);
for rule in [FillRule::NonZero, FillRule::EvenOdd] {
let Some(disc) = measure(&shape, rule) else {
continue;
};
let mut grid = 0.0_f64;
for i in 0..=200 {
for j in 0..=200 {
let at = (0.2 * f64::from(i), 0.2 * f64::from(j));
grid = grid.max(clearance(&shape, rule, at));
}
}
assert!(
disc.radius <= grid + 0.15,
"case {case}: {disc:?} vs {grid}"
);
for k in 0..90 {
let angle = f64::from(k) * std::f64::consts::TAU / 90.0;
let rim = (
disc.centre.0 + 0.999 * disc.radius * angle.cos(),
disc.centre.1 + 0.999 * disc.radius * angle.sin(),
);
assert!(clearance(&shape, rule, rim) > 0.0, "case {case}: {rim:?}");
}
}
}
}
}
+1
View File
@@ -5,6 +5,7 @@
pub mod compose; pub mod compose;
pub mod frame; pub mod frame;
pub mod interior;
pub mod layer; pub mod layer;
pub mod path; pub mod path;
pub mod svg; pub mod svg;
+257 -7
View File
@@ -10,6 +10,10 @@
//! `f32::MAX` (Chromium, WebKit; WebKit already for an arc radius of `1e30`), while a radius or a //! `f32::MAX` (Chromium, WebKit; WebKit already for an arc radius of `1e30`), while a radius or a
//! rotation that big leaves the bounds unchanged. A coordinate past the bound is outside every //! rotation that big leaves the bounds unchanged. A coordinate past the bound is outside every
//! usable frame, a radius past it draws a straight segment on one. //! usable frame, a radius past it draws a straight segment on one.
//!
//! The same reading gives a path's fill outline (`path_outline`, owner brief 2026-11-01, zone
//! without interior): each subpath as a polyline, curves and arcs cut into chords, with the
//! largest distance between a chord and its curve (`Outline::deviation`).
/// The smallest box holding a set of points. /// The smallest box holding a set of points.
#[derive(Debug, Clone, Copy, PartialEq)] #[derive(Debug, Clone, Copy, PartialEq)]
@@ -55,8 +59,45 @@ pub fn number_list(value: &str) -> Option<Vec<f64>> {
/// The bounds of every point `d` draws; `None` when a browser would not read all of it. /// The bounds of every point `d` draws; `None` when a browser would not read all of it.
pub fn path_bounds(d: &str) -> Option<Bounds> { pub fn path_bounds(d: &str) -> Option<Bounds> {
let mut cursor = Cursor::new(d);
let mut pen = Pen::default(); let mut pen = Pen::default();
read_path(d, &mut pen)?;
pen.bounds
}
/// The largest number of chords a curve or an arc is cut into: past it the deviation grows
/// instead (the measure stays conservative).
pub const MAX_CURVE_CHORDS: usize = 64;
/// A fill outline: its subpaths as polylines (each closed by the fill), the largest distance
/// between a chord and the curve it stands for, and whether more than the asked number of
/// vertices was needed (the outline is then incomplete).
#[derive(Debug, Clone, PartialEq, Default)]
pub struct Outline {
pub subpaths: Vec<Vec<(f64, f64)>>,
pub deviation: f64,
pub overflow: bool,
}
/// The outline `d` fills, curves and arcs cut into chords at most `tolerance` away from them
/// (`MAX_CURVE_CHORDS` aside), at most `max_vertices` vertices; `None` when a browser would not
/// read all of it.
pub fn path_outline(d: &str, tolerance: f64, max_vertices: usize) -> Option<Outline> {
let mut pen = Pen {
flat: Some(Flattening {
tolerance,
max_vertices,
vertices: 0,
start: None,
outline: Outline::default(),
}),
..Pen::default()
};
read_path(d, &mut pen)?;
Some(pen.flat?.outline)
}
fn read_path(d: &str, pen: &mut Pen) -> Option<()> {
let mut cursor = Cursor::new(d);
cursor.skip_space(); cursor.skip_space();
if !matches!(cursor.peek(), Some(b'M' | b'm')) { if !matches!(cursor.peek(), Some(b'M' | b'm')) {
return None; return None;
@@ -74,10 +115,7 @@ pub fn path_bounds(d: &str) -> Option<Bounds> {
} }
} }
} }
if !cursor.done() { cursor.done().then_some(())
return None;
}
pen.bounds
} }
/// A position in the text being read. /// A position in the text being read.
@@ -245,8 +283,8 @@ struct Arc {
to: (f64, f64), to: (f64, f64),
} }
/// The current point, the subpath start, the previous control point (for `S` and `T`), and /// The current point, the subpath start, the previous control point (for `S` and `T`), the
/// the bounds so far. /// bounds so far, and the outline when one is asked.
#[derive(Default)] #[derive(Default)]
struct Pen { struct Pen {
at: (f64, f64), at: (f64, f64),
@@ -254,6 +292,44 @@ struct Pen {
cubic_control: Option<(f64, f64)>, cubic_control: Option<(f64, f64)>,
quadratic_control: Option<(f64, f64)>, quadratic_control: Option<(f64, f64)>,
bounds: Option<Bounds>, bounds: Option<Bounds>,
flat: Option<Flattening>,
}
/// The outline being drawn: a subpath starts with the first point drawn after its moveto or
/// closepath, so a lone moveto adds nothing.
struct Flattening {
tolerance: f64,
max_vertices: usize,
vertices: usize,
start: Option<(f64, f64)>,
outline: Outline,
}
impl Flattening {
fn push(&mut self, point: (f64, f64)) {
if let Some(start) = self.start.take() {
self.outline.subpaths.push(Vec::new());
self.push(start);
}
if self.vertices == self.max_vertices {
self.outline.overflow = true;
return;
}
self.vertices += 1;
if let Some(subpath) = self.outline.subpaths.last_mut() {
subpath.push(point);
}
}
/// The chords for a curve whose second derivative stays within `bend`: a chord over a
/// parameter step `h` departs from the curve by at most `bend × h² / 8`.
fn chords(&mut self, bend: f64) -> usize {
let wanted = (bend / (8.0 * self.tolerance)).sqrt().ceil();
let count = wanted.clamp(1.0, MAX_CURVE_CHORDS as f64) as usize;
let step = 1.0 / count as f64;
self.outline.deviation = self.outline.deviation.max(bend * step * step / 8.0);
count
}
} }
impl Pen { impl Pen {
@@ -264,10 +340,32 @@ impl Pen {
} }
} }
/// Starts a subpath of the outline at the current point, once something is drawn from it.
fn open_subpath(&mut self) {
if let Some(flat) = &mut self.flat {
flat.start = Some(self.at);
}
}
/// The points of a curve between its ends, `count` chords over `t` in (0, 1).
fn trace(&mut self, count: usize, at: impl Fn(f64) -> (f64, f64)) {
if let Some(flat) = &mut self.flat {
for i in 1..count {
flat.push(at(i as f64 / count as f64));
}
}
}
fn chords(&mut self, bend: f64) -> usize {
self.flat.as_mut().map_or(1, |flat| flat.chords(bend))
}
/// A drawing command after a closepath starts a new subpath at the closed one's start.
fn close(&mut self) { fn close(&mut self) {
self.at = self.start; self.at = self.start;
self.cubic_control = None; self.cubic_control = None;
self.quadratic_control = None; self.quadratic_control = None;
self.open_subpath();
} }
/// One parameter group of `command`; a moveto's later pairs are linetos. /// One parameter group of `command`; a moveto's later pairs are linetos.
@@ -282,6 +380,7 @@ impl Pen {
self.at = point(x, y); self.at = point(x, y);
self.start = self.at; self.start = self.at;
self.add(self.at); self.add(self.at);
self.open_subpath();
self.cubic_control = None; self.cubic_control = None;
self.quadratic_control = None; self.quadratic_control = None;
return self.linetos(relative, cursor); return self.linetos(relative, cursor);
@@ -343,6 +442,9 @@ impl Pen {
fn line(&mut self, to: (f64, f64)) { fn line(&mut self, to: (f64, f64)) {
self.add(to); self.add(to);
if let Some(flat) = &mut self.flat {
flat.push(to);
}
self.at = to; self.at = to;
} }
@@ -359,6 +461,16 @@ impl Pen {
cubic_at(from.1, c1.1, c2.1, to.1, t), cubic_at(from.1, c1.1, c2.1, to.1, t),
)); ));
} }
let bend = 6.0
* distance(second_difference(from, c1, c2))
.max(distance(second_difference(c1, c2, to)));
let count = self.chords(bend);
self.trace(count, |t| {
(
cubic_at(from.0, c1.0, c2.0, to.0, t),
cubic_at(from.1, c1.1, c2.1, to.1, t),
)
});
self.line(to); self.line(to);
c2 c2
} }
@@ -378,6 +490,13 @@ impl Pen {
quadratic_at(from.1, control.1, to.1, t), quadratic_at(from.1, control.1, to.1, t),
)); ));
} }
let count = self.chords(2.0 * distance(second_difference(from, control, to)));
self.trace(count, |t| {
(
quadratic_at(from.0, control.0, to.0, t),
quadratic_at(from.1, control.1, to.1, t),
)
});
self.line(to); self.line(to);
control control
} }
@@ -398,10 +517,23 @@ impl Pen {
self.add(ellipse.at(angle)); self.add(ellipse.at(angle));
} }
} }
// Over the sweep as `t` goes from 0 to 1 the second derivative stays within the larger
// radius times the sweep squared.
let count = self.chords(ellipse.rx.max(ellipse.ry) * ellipse.sweep * ellipse.sweep);
self.trace(count, |t| ellipse.at(ellipse.start + ellipse.sweep * t));
self.line(arc.to); self.line(arc.to);
} }
} }
/// `a − 2b + c`, the curve's second difference over three control points.
fn second_difference(a: (f64, f64), b: (f64, f64), c: (f64, f64)) -> (f64, f64) {
(a.0 - 2.0 * b.0 + c.0, a.1 - 2.0 * b.1 + c.1)
}
fn distance((x, y): (f64, f64)) -> f64 {
x.hypot(y)
}
/// The reflection of the previous control point about the current point, or the current point. /// The reflection of the previous control point about the current point, or the current point.
fn reflect(control: Option<(f64, f64)>, at: (f64, f64)) -> (f64, f64) { fn reflect(control: Option<(f64, f64)>, at: (f64, f64)) -> (f64, f64) {
control.map_or(at, |(x, y)| (2.0 * at.0 - x, 2.0 * at.1 - y)) control.map_or(at, |(x, y)| (2.0 * at.0 - x, 2.0 * at.1 - y))
@@ -637,6 +769,124 @@ mod tests {
} }
} }
/// A curve by its parameter in [0, 1].
type Curve<'a> = Box<dyn Fn(f64) -> (f64, f64) + 'a>;
fn polyline_distance(point: (f64, f64), line: &[(f64, f64)]) -> f64 {
line.windows(2)
.map(|pair| {
let (a, b) = (pair[0], pair[1]);
let (dx, dy) = (b.0 - a.0, b.1 - a.1);
let length = dx * dx + dy * dy;
let t = if length > 0.0 {
(((point.0 - a.0) * dx + (point.1 - a.1) * dy) / length).clamp(0.0, 1.0)
} else {
0.0
};
(point.0 - a.0 - t * dx).hypot(point.1 - a.1 - t * dy)
})
.fold(f64::INFINITY, f64::min)
}
/// Every point of the curve lies within the declared deviation of its chords, and the
/// deviation within the tolerance asked unless the curve took `MAX_CURVE_CHORDS` (an arc
/// whose radii the endpoints scale up).
#[test]
fn outline_chords_stay_within_the_deviation() {
let mut rng = Lcg(13);
let tolerance = 0.05;
for case in 0..300 {
let p: Vec<f64> = (0..8).map(|_| rng.next(-50.0, 50.0)).collect();
let arc = Arc {
rx: rng.next(0.5, 30.0),
ry: rng.next(0.5, 30.0),
rotation: rng.next(-360.0, 360.0),
large: rng.next(0.0, 1.0) < 0.5,
sweep: rng.next(0.0, 1.0) < 0.5,
to: (p[6], p[7]),
};
let curves: [(String, Curve<'_>); 3] = [
(
format!(
"M{} {}C{} {} {} {} {} {}",
p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]
),
Box::new(|t| {
(
cubic_at(p[0], p[2], p[4], p[6], t),
cubic_at(p[1], p[3], p[5], p[7], t),
)
}),
),
(
format!("M{} {}Q{} {} {} {}", p[0], p[1], p[2], p[3], p[6], p[7]),
Box::new(|t| {
(
quadratic_at(p[0], p[2], p[6], t),
quadratic_at(p[1], p[3], p[7], t),
)
}),
),
(
format!(
"M{} {}A{} {} {} {} {} {} {}",
p[0],
p[1],
arc.rx,
arc.ry,
arc.rotation,
u8::from(arc.large),
u8::from(arc.sweep),
p[6],
p[7]
),
{
let ellipse = Ellipse::through((p[0], p[1]), &arc);
Box::new(move |t| ellipse.at(ellipse.start + ellipse.sweep * t))
},
),
];
for (d, at) in &curves {
let outline = path_outline(d, tolerance, 4096).unwrap();
assert_eq!(outline.subpaths.len(), 1, "{d}");
let line = &outline.subpaths[0];
let capped = line.len() == MAX_CURVE_CHORDS + 1;
assert!(
outline.deviation <= tolerance || capped,
"case {case} {d}: {}",
outline.deviation
);
for i in 0..=2000 {
let point = at(f64::from(i) / 2000.0);
let gap = polyline_distance(point, line);
assert!(gap <= outline.deviation + 1e-9, "case {case} {d}: {gap}");
}
}
}
}
#[test]
fn a_closepath_starts_the_next_subpath_at_its_start() {
let outline = path_outline("M0 0h10v10h-10zh-10v10h10z", 0.05, 4096).unwrap();
assert_eq!(
outline.subpaths,
[
vec![(0.0, 0.0), (10.0, 0.0), (10.0, 10.0), (0.0, 10.0)],
vec![(0.0, 0.0), (-10.0, 0.0), (-10.0, 10.0), (0.0, 10.0)],
]
);
assert_eq!(outline.deviation, 0.0);
let lone = path_outline("M5 5M0 0h1v1z", 0.05, 4096).unwrap();
assert_eq!(lone.subpaths.len(), 1, "a lone moveto fills nothing");
}
#[test]
fn the_outline_stops_at_its_vertex_cap() {
let d = format!("M0 0{}", "l1 1".repeat(9));
assert!(!path_outline(&d, 0.05, 10).unwrap().overflow);
assert!(path_outline(&d, 0.05, 9).unwrap().overflow);
}
#[test] #[test]
fn the_grammar_is_read_as_a_browser_reads_it() { fn the_grammar_is_read_as_a_browser_reads_it() {
let read = |d: &str| path_bounds(d).map(|b| (b.min_x, b.min_y, b.max_x, b.max_y)); let read = |d: &str| path_bounds(d).map(|b| (b.min_x, b.min_y, b.max_x, b.max_y));
+11
View File
@@ -28,6 +28,9 @@ pub const NO_FRAME: &str = "view.frame.unknown";
/// An annotation in frame that shows below `anatomy::frame::MIN_VISIBLE_PX` on the smallest /// An annotation in frame that shows below `anatomy::frame::MIN_VISIBLE_PX` on the smallest
/// preview (owner brief 2026-11-01, the scale bypass). /// preview (owner brief 2026-11-01, the scale bypass).
pub const TOO_SMALL: &str = "annotation.geometry.too_small"; pub const TOO_SMALL: &str = "annotation.geometry.too_small";
/// A polygon or a path in frame whose fill holds no disc of `anatomy::frame::MIN_VISIBLE_PX` on
/// the smallest preview (owner brief 2026-11-01, zone without interior; `anatomy::interior`).
pub const INTERIOR_TOO_SMALL: &str = "annotation.geometry.interior_too_small";
#[derive(Debug, Clone, PartialEq, Eq, Serialize)] #[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[cfg_attr(feature = "ts", derive(TS), ts(export))] #[cfg_attr(feature = "ts", derive(TS), ts(export))]
@@ -123,6 +126,14 @@ fn frame_issue(document: &AnatomicalSheetDocument, fault: &FrameFault) -> SheetI
let (code, what) = match placement { let (code, what) = match placement {
Placement::Unreadable => (OUT_OF_FRAME, "has path data that cannot be read whole"), Placement::Unreadable => (OUT_OF_FRAME, "has path data that cannot be read whole"),
Placement::TooSmall => (TOO_SMALL, "shows too small on the phone preview"), Placement::TooSmall => (TOO_SMALL, "shows too small on the phone preview"),
Placement::InteriorTooSmall => (
INTERIOR_TOO_SMALL,
"fills no interior wide enough to tap on the phone preview",
),
Placement::InteriorUnmeasured => (
INTERIOR_TOO_SMALL,
"is too complex for the interior measure on the phone preview",
),
Placement::InFrame | Placement::OutOfFrame => { Placement::InFrame | Placement::OutOfFrame => {
(OUT_OF_FRAME, "is not entirely inside the frame") (OUT_OF_FRAME, "is not entirely inside the frame")
} }
+9 -2
View File
@@ -21,8 +21,8 @@ use ts_rs::TS;
use super::caps::CapsReport; use super::caps::CapsReport;
use super::fingerprint::{FingerprintError, document_fingerprint}; use super::fingerprint::{FingerprintError, document_fingerprint};
use super::report::{ use super::report::{
NO_FRAME, OUT_OF_FRAME, SheetReport, TOO_SMALL, frame_issues, referenced_asset_ids, INTERIOR_TOO_SMALL, NO_FRAME, OUT_OF_FRAME, SheetReport, TOO_SMALL, frame_issues,
sheet_report, referenced_asset_ids, sheet_report,
}; };
use super::review::{Completeness, ElementChange, ReviewGroup, change_list}; use super::review::{Completeness, ElementChange, ReviewGroup, change_list};
use super::schema::AnatomicalSheetDocument; use super::schema::AnatomicalSheetDocument;
@@ -58,6 +58,9 @@ pub mod codes {
/// An annotation in frame that shows below 4 CSS px on the smallest preview (owner brief /// An annotation in frame that shows below 4 CSS px on the smallest preview (owner brief
/// 2026-11-01): measured on the same views. /// 2026-11-01): measured on the same views.
pub const MARKER_TOO_SMALL: &str = "verification.validation.marker_too_small"; pub const MARKER_TOO_SMALL: &str = "verification.validation.marker_too_small";
/// A polygon or a path in frame whose fill holds no disc of 4 CSS px on that preview, its
/// stroke left out (owner brief 2026-11-01, zone without interior).
pub const MARKER_INTERIOR_TOO_SMALL: &str = "verification.validation.marker_interior_too_small";
pub const FINGERPRINT: &str = "verification.integrity.fingerprint"; pub const FINGERPRINT: &str = "verification.integrity.fingerprint";
} }
@@ -285,6 +288,7 @@ fn rule_failures(report: &SheetReport) -> Vec<&'static str> {
OUT_OF_FRAME, OUT_OF_FRAME,
NO_FRAME, NO_FRAME,
TOO_SMALL, TOO_SMALL,
INTERIOR_TOO_SMALL,
] ]
.contains(&code) .contains(&code)
}; };
@@ -316,6 +320,9 @@ fn frame_failures(report: &SheetReport) -> Vec<&'static str> {
if found(&[TOO_SMALL]) { if found(&[TOO_SMALL]) {
out.push(codes::MARKER_TOO_SMALL); out.push(codes::MARKER_TOO_SMALL);
} }
if found(&[INTERIOR_TOO_SMALL]) {
out.push(codes::MARKER_INTERIOR_TOO_SMALL);
}
out out
} }
+232
View File
@@ -0,0 +1,232 @@
//! The browser proof of the interior rule (owner brief « V1-2.2 : fermeture du dernier MEDIUM »,
//! 2026-11-01): `apps/app/e2e/fixtures/interior-probe.json`, read by
//! `apps/app/e2e/ui/interior-clicks.spec.ts` in Chromium, Firefox and WebKit. Each case is a
//! sheet whose main view, framed `0 0 286 310` (one unit per CSS px on the phone preview), holds
//! one shape: the canvas the editor gets (`view.canvas`), the verdict's code, and the widest disc
//! the core measures. The equine draft's shapes give their discs too. The file is generated
//! here and compared byte for byte; `MAKE_INTERIOR_PROBE=1` writes it.
#![allow(clippy::disallowed_methods, clippy::unwrap_used, clippy::expect_used)]
mod common;
use common::sheet_readers::{DETAIL_ASSET, MAIN_ASSET, OPEN, document, drawing};
use faunosteo_core::anatomy::interior::{
Budget, LAYER_FILL_RULE, Search, geometry_outline, widest_disc,
};
use faunosteo_core::domain::sheet::preview::{PreviewInput, PreviewSheet, PreviewStatus};
use faunosteo_core::domain::sheet::{AnatomicalSheetDocument, Annotation, Geometry};
use faunosteo_core::facade::call_with_preview;
use serde_json::{Value, json};
const FIXTURE: &str = "apps/app/e2e/fixtures/interior-probe.json";
const THIN: &str = "annotation.geometry.interior_too_small";
const PHONE: &str = "0 0 286 310";
/// The widest disc of a shape, measured to a thousandth of a unit: centre and radius.
fn widest(geometry: &Geometry) -> Value {
let outline = geometry_outline(geometry, 0.001).unwrap();
let search = Search {
floor: 0.0,
enough: f64::INFINITY,
precision: 0.001,
};
match widest_disc(&outline, LAYER_FILL_RULE, &search, &mut Budget::default()) {
Some(disc) => json!({
"x": round(disc.centre.0),
"y": round(disc.centre.1),
"r": round(disc.radius),
}),
None => Value::Null,
}
}
fn round(value: f64) -> f64 {
(value * 1000.0).round() / 1000.0
}
/// One case: the canvas, the frame codes, the widest disc.
fn case(name: &str, geometry: Value, root: &str) -> Value {
let mut doc: Value = serde_json::from_str(&document()).unwrap();
doc["annotations"][0]["id"] = json!("shape");
doc["annotations"][0]["kind"] = json!("zone");
doc["annotations"][0]["geometry"] = geometry.clone();
let main = OPEN.replace(
"viewBox=\"0 0 10 10\"",
&format!("{root}viewBox=\"{PHONE}\""),
) + "<path d=\"M0 0h1\"/></svg>";
let detail = OPEN.to_owned() + "<path d=\"M0 0h1\"/></svg>";
let input = PreviewInput {
status: PreviewStatus::Draft,
document: doc.to_string(),
fingerprint: None,
};
let preview = PreviewSheet::load(
input,
vec![drawing(MAIN_ASSET, &main), drawing(DETAIL_ASSET, &detail)],
)
.unwrap();
let codes: Vec<String> = preview
.state()
.unwrap()
.report
.issues
.iter()
.filter(|i| i.code.starts_with("annotation.geometry."))
.map(|i| i.code.clone())
.collect();
let canvas: Value = serde_json::from_str(&call_with_preview(
&preview,
"view.canvas",
&json!({ "viewId": "main" }).to_string(),
))
.unwrap();
assert_eq!(canvas["ok"], json!(true), "{name}: {canvas}");
let typed: Geometry = serde_json::from_value(geometry).unwrap();
json!({
"name": name,
"accepted": codes.is_empty(),
"codes": codes,
"widest": widest(&typed),
"svg": canvas["value"]["svg"],
})
}
fn polygon(points: &[[f64; 2]]) -> Value {
json!({ "type": "polygon", "points": points })
}
fn path(d: &str) -> Value {
json!({ "type": "path", "d": d })
}
fn ell(x: f64, y: f64, w: f64) -> Value {
polygon(&[
[x, y],
[x + 40.0, y],
[x + 40.0, y + w],
[x + w, y + w],
[x + w, y + 40.0],
[x, y + 40.0],
])
}
fn star(cx: f64, cy: f64, r: f64) -> Value {
let points: Vec<[f64; 2]> = (0..5)
.map(|i| {
let angle =
-std::f64::consts::FRAC_PI_2 + f64::from(i * 2) * std::f64::consts::TAU / 5.0;
[cx + r * angle.cos(), cy + r * angle.sin()]
})
.collect();
polygon(&points)
}
fn cases() -> Vec<Value> {
let plain = "";
vec![
// Accepted: small shapes that fill.
case(
"square-6",
polygon(&[[40.0, 40.0], [46.0, 40.0], [46.0, 46.0], [40.0, 46.0]]),
plain,
),
case(
"flat-triangle",
polygon(&[[40.0, 40.0], [100.0, 40.0], [70.0, 44.6]]),
plain,
),
case(
"arc-disc-6",
path("M40 50a3 3 0 1 0 6 0a3 3 0 1 0 -6 0Z"),
plain,
),
case(
"cubic-lens",
path("M40 50C50 44 70 44 80 50C70 56 50 56 40 50Z"),
plain,
),
case("ell-3.6", ell(40.0, 40.0, 3.6), plain),
// Winding 2 at the centre: filled by the layer's nonzero rule, whatever the drawing says.
case(
"pentagram-evenodd-root",
star(60.0, 60.0, 10.0),
"fill-rule=\"evenodd\" ",
),
// Refused: no interior a tap reaches on the phone.
case("forth-and-back", path("M40 40L90 90L40 40"), plain),
case(
"square-twice-opposite",
path("M40 40h40v40h-40zM40 40v40h40v-40z"),
plain,
),
case(
"diagonal-sliver",
polygon(&[[40.0, 40.0], [90.0, 90.0], [90.0, 88.6]]),
plain,
),
case(
"cubic-there-and-back",
path("M40 80C50 40 80 40 90 80C80 40 50 40 40 80Z"),
plain,
),
case(
"arc-there-and-back",
path("M40 80A25 25 0 0 1 90 80A25 25 0 0 0 40 80Z"),
plain,
),
case(
"flat-ellipse-45",
path("M40 40A35 1 45 0 1 90 90A35 1 45 0 1 40 40Z"),
plain,
),
case("ell-3.3", ell(40.0, 40.0, 3.3), plain),
case(
"triangle-6.6",
polygon(&[[40.0, 45.716], [46.6, 45.716], [43.3, 40.0]]),
plain,
),
]
}
/// The equine draft's polygons and paths: their widest disc, in the frame's units.
fn equine() -> Vec<Value> {
let text = common::repo_file("supabase/seed/anatomical-sheets/equine/draft/document.json");
let doc: AnatomicalSheetDocument = serde_json::from_str(&text).unwrap();
doc.annotations
.iter()
.filter_map(|a| {
let geometry = match a {
Annotation::Observable(o) => o.geometry.as_ref(),
Annotation::DetailTrigger(t) => t.geometry.as_ref(),
}?;
if matches!(geometry, Geometry::Circle(_)) {
return None;
}
Some(json!({ "id": a.id(), "view": a.view_id(), "widest": widest(geometry) }))
})
.collect()
}
#[test]
fn the_interior_probe_is_current() {
let cases = cases();
for c in &cases {
let refused = c["codes"] == json!([THIN]);
assert!(c["accepted"] == json!(true) || refused, "{}", c["name"]);
}
let probe = json!({
"generatedBy": "crates/core/tests/interior_probe.rs",
"frame": { "width": 286, "height": 310 },
"cases": cases,
"equine": equine(),
});
let text = serde_json::to_string_pretty(&probe).unwrap() + "\n";
let path = format!("{}/../../{FIXTURE}", env!("CARGO_MANIFEST_DIR"));
if std::env::var("MAKE_INTERIOR_PROBE").is_ok_and(|v| v == "1") {
std::fs::write(&path, &text).unwrap();
}
assert!(
common::repo_file(FIXTURE) == text,
"{FIXTURE} is stale: MAKE_INTERIOR_PROBE=1 cargo test --test interior_probe"
);
}
+188 -15
View File
@@ -24,10 +24,12 @@ use serde_json::{Value, json};
const SEED: &str = "supabase/seed/anatomical-sheets/equine/draft"; const SEED: &str = "supabase/seed/anatomical-sheets/equine/draft";
const HORSE_ID: &str = "7f767f74-3b36-51a7-8465-52dd7e2ead4a"; const HORSE_ID: &str = "7f767f74-3b36-51a7-8465-52dd7e2ead4a";
const TOO_SMALL: &str = "annotation.geometry.too_small"; const TOO_SMALL: &str = "annotation.geometry.too_small";
const THIN: &str = "annotation.geometry.interior_too_small";
const NO_FRAME: &str = "view.frame.unknown"; const NO_FRAME: &str = "view.frame.unknown";
const OUT_OF_FRAME: &str = "annotation.geometry.out_of_frame"; const OUT_OF_FRAME: &str = "annotation.geometry.out_of_frame";
/// The verdict's closed codes, as the SQL stores them. /// The verdict's closed codes, as the SQL stores them.
const SMALL_FAILURE: &str = "verification.validation.marker_too_small"; const SMALL_FAILURE: &str = "verification.validation.marker_too_small";
const THIN_FAILURE: &str = "verification.validation.marker_interior_too_small";
const FRAME_FAILURE: &str = "verification.validation.out_of_frame"; const FRAME_FAILURE: &str = "verification.validation.out_of_frame";
/// The frame and size issues `(code, path)`, the verdict and the preview agreeing, and the /// The frame and size issues `(code, path)`, the verdict and the preview agreeing, and the
@@ -68,7 +70,7 @@ fn judged(
let state = PreviewSheet::load(input, given).unwrap().state().unwrap(); let state = PreviewSheet::load(input, given).unwrap().state().unwrap();
let issues = |all: &[faunosteo_core::domain::sheet::SheetIssue]| -> Vec<(String, String)> { let issues = |all: &[faunosteo_core::domain::sheet::SheetIssue]| -> Vec<(String, String)> {
all.iter() all.iter()
.filter(|i| [TOO_SMALL, NO_FRAME, OUT_OF_FRAME].contains(&i.code.as_str())) .filter(|i| [TOO_SMALL, THIN, NO_FRAME, OUT_OF_FRAME].contains(&i.code.as_str()))
.map(|i| (i.code.clone(), i.path.clone())) .map(|i| (i.code.clone(), i.path.clone()))
.collect() .collect()
}; };
@@ -179,28 +181,50 @@ fn the_blown_up_horse_is_refused() {
assert_eq!(text, equine(), "the document is never rewritten"); assert_eq!(text, equine(), "the document is never rewritten");
} }
/// The threshold on the real sheet: the junctions fall below 4 px once the horse is scaled by /// The threshold on the real sheet. The caudal zone's widest disc (4.951 px) falls below 4 px
/// more than 4.966 / 4 ≈ 1.2414; the other points (disc r 22) hold until ≈ 1.517. /// first, once the horse is scaled by more than 4.951 / 4 ≈ 1.2378; then the junctions, past
/// 4.966 / 4 ≈ 1.2414; the other points (disc r 22) hold until ≈ 1.517, the other zones (at
/// least 11.30 px) until ≈ 2.8. In doubt the measure refuses: at 1.236 (4.006 px) the search,
/// which cuts no cell below 0.05 px, has not shown the disc.
#[test] #[test]
fn the_equine_threshold_falls_on_the_junctions_first() { fn the_equine_threshold_falls_on_the_caudal_zone_then_the_junctions() {
let text = equine(); let text = equine();
let small = |factor: f64| -> Vec<String> { let small = |factor: f64| -> Vec<(String, String)> {
let (issues, _) = judged(&text, &[(HORSE_ID, &scaled_horse(factor))]); let (issues, _) = judged(&text, &[(HORSE_ID, &scaled_horse(factor))]);
let doc: Value = serde_json::from_str(&text).unwrap(); let doc: Value = serde_json::from_str(&text).unwrap();
issues let mut found: Vec<(String, String)> = issues
.iter() .iter()
.map(|(_, path)| { .map(|(code, path)| {
let index: usize = path[12..path.len() - 10].parse().unwrap(); let index: usize = path[12..path.len() - 10].parse().unwrap();
doc["annotations"][index]["id"].as_str().unwrap().to_owned() let id = doc["annotations"][index]["id"].as_str().unwrap();
(id.to_owned(), code.clone())
}) })
.collect() .collect();
found.sort();
found
}; };
assert!(small(1.24).is_empty()); let pair = |id: &str, code: &str| (id.to_owned(), code.to_owned());
let mut junctions = small(1.25); assert!(small(1.23).is_empty());
junctions.sort(); assert_eq!(small(1.24), [pair("caudal", THIN)]);
assert_eq!(junctions, ["c7-t1", "l6-s1", "t18-l1"]); let (_, failures) = judged(&text, &[(HORSE_ID, &scaled_horse(1.24))]);
assert_eq!(small(1.51).len(), 3); assert_eq!(
assert_eq!(small(1.52).len(), 13, "every point, the zones still shown"); failures,
[THIN_FAILURE],
"the interior alone, never a rules failure"
);
assert_eq!(
small(1.25),
[
pair("c7-t1", TOO_SMALL),
pair("caudal", THIN),
pair("l6-s1", TOO_SMALL),
pair("t18-l1", TOO_SMALL),
]
);
assert_eq!(small(1.51).len(), 4);
let past = small(1.52);
assert_eq!(past.len(), 14, "every point and the caudal zone");
assert_eq!(past.iter().filter(|(_, code)| code == THIN).count(), 1);
} }
/// A point shows its visible disc, `2 × max(2, r − 12)`, never its transparent hitbox; at /// A point shows its visible disc, `2 × max(2, r − 12)`, never its transparent hitbox; at
@@ -381,3 +405,152 @@ fn path_numbers_past_the_frame_magnitude_are_refused() {
assert_eq!(main(d), [OUT_OF_FRAME], "{d}"); assert_eq!(main(d), [OUT_OF_FRAME], "{d}");
} }
} }
/// The last MEDIUM (owner brief 2026-11-01, zone without interior): a polygon or a path must fill
/// a disc of 4 px on the smallest preview, its stroke left out. A frame of 286 × 310 units shows
/// one unit per CSS px on the main view. Each shape passes the bounds rule (it was accepted
/// before this rule) and is now refused.
#[test]
fn shapes_without_a_usable_interior_are_refused() {
let phone = "0 0 286 310";
let hostile = [
// A path drawn forth and back: winding 0 everywhere.
path("M20 20L200 200L20 20"),
path("M20 20L200 20L200 200L200 20Z"),
// The same square twice, in opposite directions: winding 0 under nonzero.
path("M20 20h100v100h-100zM20 20v100h100v-100z"),
// A near-flat polygon on the diagonal, 1 px thick, 180 px of bounds.
json!({ "type": "polygon", "points": [[20, 20], [200, 200], [200, 198.6]] }),
// A cubic and an arc travelled there and back.
path("M20 150C60 20 160 20 200 150C160 20 60 20 20 150Z"),
path("M20 150A90 90 0 0 1 200 150A90 90 0 0 0 20 150Z"),
// A flat ellipse turned 45°: 2 px thick, 127 px of bounds.
path("M50 50A127 1 45 0 1 230 230A127 1 45 0 1 50 50Z"),
// An L whose arms are 3.3 px wide: its widest disc, at the elbow, is 3.87 px.
json!({ "type": "polygon", "points": [[20, 20], [80, 20], [80, 23.3], [23.3, 23.3], [23.3, 80], [20, 80]] }),
];
for geometry in hostile {
let found = on_main(geometry.clone(), phone);
assert_eq!(codes(&found), [THIN], "{geometry}");
assert!(found.1.iter().any(|f| f == THIN_FAILURE), "{:?}", found.1);
}
}
/// Small shapes that fill: a 4.5 px tall triangle, a disc of 6 px drawn with two arcs, a cubic
/// lens, the L with 3.6 px arms (4.22 px at the elbow), a pentagram whose centre has winding 2
/// (the layer fills nonzero: 6.18 px; under evenodd only a tip would hold 3.26 px).
#[test]
fn small_shapes_that_fill_are_accepted() {
let phone = "0 0 286 310";
let legitimate = [
json!({ "type": "polygon", "points": [[20, 20], [200, 20], [110, 24.5]] }),
path("M100 100a3 3 0 1 0 6 0a3 3 0 1 0 -6 0Z"),
path("M20 100C40 90 60 90 80 100C60 110 40 110 20 100Z"),
json!({ "type": "polygon", "points": [[20, 20], [80, 20], [80, 23.6], [23.6, 23.6], [23.6, 80], [20, 80]] }),
json!({ "type": "polygon", "points": star(100.0, 100.0, 10.0) }),
];
for geometry in legitimate {
assert!(
codes(&on_main(geometry.clone(), phone)).is_empty(),
"{geometry}"
);
}
}
fn star(cx: f64, cy: f64, r: f64) -> Vec<[f64; 2]> {
(0..5)
.map(|i| {
let angle =
-std::f64::consts::FRAC_PI_2 + f64::from(i * 2) * std::f64::consts::TAU / 5.0;
[cx + r * angle.cos(), cy + r * angle.sin()]
})
.collect()
}
/// The threshold, on a shape whose widest disc is off its bounds' centre: an L with arms `w`
/// wide holds a disc of `2√2 w / (1 + √2)` at its elbow, a sharp peak the search approaches
/// from below. In doubt it refuses: measured, the first L accepted holds 4.026 px.
#[test]
fn the_interior_threshold_holds_at_its_edge() {
let elbow = |w: f64| {
let shape = json!({ "type": "polygon", "points": [[20, 20], [80, 20], [80, 20.0 + w], [20.0 + w, 20.0 + w], [20.0 + w, 80], [20, 80]] });
codes(&on_main(shape, "0 0 286 310"))
};
let diameter = |w: f64| 2.0 * std::f64::consts::SQRT_2 * w / (1.0 + std::f64::consts::SQRT_2);
assert!((diameter(3.44) - 4.030).abs() < 1e-3);
assert!(elbow(3.44).is_empty(), "4.030 px");
assert_eq!(elbow(3.43), [THIN], "4.019 px, in the doubt band");
assert_eq!(elbow(3.41), [THIN], "3.995 px");
}
/// Extreme frames and scales: the measure follows the projection, not the units. The same L at
/// a tenth of the scale, near the offset limit, and in a one-unit frame.
#[test]
fn the_interior_follows_the_projection() {
let l = |x: f64, y: f64, unit: f64, w: f64| {
let p = |a: f64, b: f64| [x + a * unit, y + b * unit];
json!({ "type": "polygon", "points": [p(0.0, 0.0), p(60.0, 0.0), p(60.0, w), p(w, w), p(w, 60.0), p(0.0, 60.0)] })
};
// Ten units per px.
assert!(codes(&on_main(l(200.0, 200.0, 10.0, 3.6), "0 0 2860 3100")).is_empty());
assert_eq!(
codes(&on_main(l(200.0, 200.0, 10.0, 3.3), "0 0 2860 3100")),
[THIN]
);
// The far edge at 256 spans (`MAX_FRAME_OFFSET_RATIO`): 2 860 units across, 0.1 px each.
let near = MAX_FRAME_OFFSET_RATIO * 2860.0 - 2860.0;
let frame = format!("{near} 0 2860 3100");
assert!(codes(&on_main(l(near + 200.0, 200.0, 10.0, 3.6), &frame)).is_empty());
assert_eq!(
codes(&on_main(l(near + 200.0, 200.0, 10.0, 3.3), &frame)),
[THIN]
);
// A one-unit frame: 286 px per unit.
let unit = 1.0 / 286.0;
assert!(codes(&on_main(l(0.1, 0.1, unit, 3.6), "0 0 1 1.0839")).is_empty());
assert_eq!(
codes(&on_main(l(0.1, 0.1, unit, 3.3), "0 0 1 1.0839")),
[THIN]
);
}
/// A drawing scaled inside never changes the interior: the markers are drawn in the frame.
#[test]
fn drawing_transforms_never_change_the_interior() {
let mut doc: Value = serde_json::from_str(&document()).unwrap();
doc["annotations"][0]["geometry"] = path("M20 20L200 200L20 20");
let scaled = OPEN.replace("0 0 10 10", "0 0 286 310")
+ "<g transform=\"scale(1000)\"><path d=\"M0 0h10v10z\"/></g></svg>";
let plain = OPEN.to_owned() + "<path d=\"M0 0h1\"/></svg>";
let (issues, _) = judged(
&doc.to_string(),
&[(MAIN_ASSET, &scaled), (DETAIL_ASSET, &plain)],
);
assert_eq!(
issues,
[(THIN.to_owned(), "annotations[0].geometry".to_owned())]
);
}
/// Over the measure's caps the shape is refused, never accepted: a disc drawn with 5 000 vertices.
#[test]
fn a_shape_too_complex_to_measure_is_refused() {
let ring = |count: u32| {
let points: Vec<[f64; 2]> = (0..count)
.map(|i| {
let angle = f64::from(i) * std::f64::consts::TAU / f64::from(count);
[143.0 + 100.0 * angle.cos(), 155.0 + 100.0 * angle.sin()]
})
.collect();
json!({ "type": "polygon", "points": points })
};
assert!(codes(&on_main(ring(4096), "0 0 286 310")).is_empty());
assert_eq!(codes(&on_main(ring(4097), "0 0 286 310")), [THIN]);
// The same cap on a path's outline, its curves' chords counted.
let square = |sides: usize| format!("M40 40{}h100v100h-100Z", "h0.001".repeat(sides));
assert_eq!(
codes(&on_main(path(&square(4092)), "0 0 286 310")),
Vec::<String>::new()
);
assert_eq!(codes(&on_main(path(&square(4093)), "0 0 286 310")), [THIN]);
}
+10 -1
View File
@@ -96,7 +96,16 @@ draw faithfully (edges within 2²⁰, spans from 1 unit, aspect at most
every annotation must show at least 4 CSS px on the smallest preview, the every annotation must show at least 4 CSS px on the smallest preview, the
editor at 320 × 568 (`verification.validation.marker_too_small`): a frame editor at 320 × 568 (`verification.validation.marker_too_small`): a frame
blown up with its drawing scaled back keeps the drawing and shrinks every blown up with its drawing scaled back keeps the drawing and shrinks every
marker, refused. marker, refused. A zone or a trigger drawn as a polygon or a path must also
fill a disc of 4 CSS px on that preview, under the `nonzero` rule the layer
fills with (it writes no `fill-rule`, and none reaches it), its stroke left out
(`verification.validation.marker_interior_too_small`, owner brief 2026-11-01):
an outline drawn forth and back, the same loop twice in opposite directions, or
a near-flat shape on a diagonal fills no point a tap can reach, refused. The
measure is conservative (a disc crossing no edge, curves cut into chords whose
deviation is taken off) and refuses in doubt; a point painted over a zone takes
the taps on its disc, which the measure does not count (known limitation,
RUST.md §12.14).
The editor canvas is inlined in the page, where `#id` resolves against the The editor canvas is inlined in the page, where `#id` resolves against the
whole document. Since V1-2.2 (owner decision 2026-10-29) the core writes whole document. Since V1-2.2 (owner decision 2026-10-29) the core writes
+10 -1
View File
@@ -123,7 +123,16 @@ suite needs Docker in the runner for the sandbox.
100.9 left of it; Chromium keeps the fraction on a click, rounds a tap), so a 100.9 left of it; Chromium keeps the fraction on a click, rounds a tap), so a
real press keeps 1.5 px of margin from any edge it tests; below that margin real press keeps 1.5 px of margin from any edge it tests; below that margin
the spec asks the browser's own hit test (`elementFromPoint`) at the exact the spec asks the browser's own hit test (`elementFromPoint`) at the exact
point. Firefox, WebKit point. `e2e/ui/interior-clicks.spec.ts` runs on the same six projects
(V1-2.2, the interior rule): the core's probe cases
(`e2e/fixtures/interior-probe.json`, generated and drift-checked by
`crates/core/tests/interior_probe.rs`, `MAKE_INTERIOR_PROBE=1` rewrites it) in
the phone preview's 286 × 310 box (harness `e2e/harness/interior.{html,ts}`,
dev server only), then the equine zones in the canvas harness. Chromium's touch
adjustment gives a point the taps up to about 10 px around its disc
(measured 2026-11-01, `chromium-320` and `chromium-375`; WebKit 375 does
not), so the real press on an equine zone goes where its fill lies farthest
from every disc. Firefox, WebKit
and the 412 × 915 viewport join every suite at V1-5 and the 412 × 915 viewport join every suite at V1-5
(contract §12.5). WebKit's system libraries may need `sudo` (owner action). (contract §12.5). WebKit's system libraries may need `sudo` (owner action).
Desktop WebKit is not iOS Safari: the owner's manual check on a real iPhone Desktop WebKit is not iOS Safari: the owner's manual check on a real iPhone
+69
View File
@@ -4342,3 +4342,72 @@ security review measured its consequence (MEDIUM, open, owner decision): a zone
(an outline traced twice in opposite directions) or a near-collinear polygon passes the 4 px rule, paints no interior (an outline traced twice in opposite directions) or a near-collinear polygon passes the 4 px rule, paints no interior
and is hit only on its 2-unit stroke (0.28 CSS px on the equine phone scale), in the three engines. Closing it needs a and is hit only on its 2-unit stroke (0.28 CSS px on the equine phone scale), in the three engines. Closing it needs a
filled-area measure (nonzero rule) or a « zone without interior » issue. filled-area measure (nonzero rule) or a « zone without interior » issue.
### 12.14 The last MEDIUM: zone without interior (owner, 2026-11-01)
Brief « V1-2.2 : fermeture du dernier MEDIUM » on `de2dfb3`: the decisions of §12.13 confirmed (threshold, frame rule,
bounds, codes `too_small` / `marker_too_small`, isolation, canvas passes, PDF order and bytes, R3 transforms, R4.1
manifest, the five former `fixme`); a zone without a usable filled interior refused by the verifier, in the core.
**Rule** (`anatomy::interior`, called by `frame::annotation_placement` after the bounds rule, so by the verdict and the
preview): a polygon or a path annotation (zone or trigger) must fill a disc of `MIN_VISIBLE_PX` 4 CSS px across on the
smallest preview (§12.13: main 286 × 310, detail 254 × 191, `xMidYMid meet`). Circles keep their exact disc measure.
| Part | What and why | Where |
|---|---|---|
| Fill rule | `nonzero` (`LAYER_FILL_RULE`): the layer writes no `fill-rule`, the composition root carries none, the drawing's sits in its own group (§12.12). The measure takes either rule; `evenodd` is tested, never used by the layer | `interior::FillRule` |
| Stroke | never counted: the measure reads the fill alone, whatever the shape's `pointer-events` (`all` on zones and triggers, its 2-unit stroke taken by the browser too) | |
| Outline | a polygon's points; a path read by the one SVG path reader (`path::path_outline`, same grammar and `±2²⁰` bound as `path_bounds`), each subpath closed by the fill, a lone moveto adding nothing; cubics, quadratics and arcs cut into chords: over a parameter step `h` a chord departs from its curve by at most `K h² / 8`, `K` bounding the second derivative (cubic `6 max‖Δ²‖`, quadratic `2‖Δ²‖`, arc `max(rx, ry) × sweep²`, the radii as scaled to reach the endpoint); chords asked within 0.05 px (`INTERIOR_TOLERANCE_PX`), at most `MAX_CURVE_CHORDS` 64 per curve, the largest deviation recorded | `path::Outline` |
| Measure | the widest disc whose centre the rule puts inside and every edge (closing edges included) at least the radius away: the disc crosses no edge, so all of it has the centre's winding number; the deviation taken off the radius. Conservative: a nonzero fill running on past an inner edge is not counted (pentagram: 3.09 measured, 3.82 filled) | `interior::widest_disc` |
| Search | polylabel's subdivision: square cells from one covering the outline, a cell's best centre at most its centre's radius plus its half diagonal, the most promising cell cut first (a max-heap ordered by `total_cmp`), cells below 0.05 px never cut; deterministic. Refuses in doubt: measured, the first L accepted at its elbow holds 4.026 px | |
| Caps | 4 096 outline vertices (`MAX_OUTLINE_VERTICES`), 4 096 cells per shape, one budget of `2²⁵` edge distances per sheet (`MAX_INTERIOR_WORK`, 0.35 s natively at 8 192 edges × 4 096 cells; the equine takes about 10⁵): a shape over them is refused, never accepted | `interior::Budget` |
| Refusal | issue `annotation.geometry.interior_too_small` (« fills no interior wide enough to tap », or « too complex for the interior measure »), verdict `verification.validation.marker_interior_too_small` after `marker_too_small`, never a rules failure; the document never rewritten | `report.rs`, `verdict.rs` |
Threshold, measured before freezing (equine draft, 320 × 568, widest disc across): caudal 4.951 px, sacral 11.30,
thoracic 11.47, cervical 12.17, lumbar 14.15, head trigger 29.13. 4 px keeps the approved threshold of the points (a point
shows a 4 px disc, a zone must hold one) and refuses no equine shape; the caudal zone now falls first when the horse is
scaled, past × 1.2378 (4.951 / 4), before the junctions (× 1.2414). Above 4.95 px the threshold would refuse the
validated equine; below, a tap target smaller than the points'.
| Proof | Result |
|---|---|
| `sheet_marker_visibility::shapes_without_a_usable_interior_are_refused` | each accepted before this rule (bounds pass): a path forth and back, a triangle traced back on itself, the same square twice in opposite directions, a 1 px diagonal sliver, a cubic and an arc travelled there and back, a 2 px ellipse turned 45°, an L of 3.3 px arms (3.87 px): `interior_too_small`, `marker_interior_too_small` |
| `small_shapes_that_fill_are_accepted` | a 4.5 px tall triangle, a 6 px disc of two arcs, a cubic lens, an L of 3.6 px arms (4.22 px), a pentagram of winding 2 (6.18 px; 3.26 under evenodd) |
| `the_interior_threshold_holds_at_its_edge` | L at 4.030 px accepted, 4.019 (doubt band) and 3.995 refused |
| `the_interior_follows_the_projection` | the same L at ten units per px, at the offset limit (256 spans), in a one-unit frame (286 px per unit) |
| `drawing_transforms_never_change_the_interior`, `a_shape_too_complex_to_measure_is_refused` | a drawing scaled × 1 000 changes nothing; 4 096 vertices measured, 4 097 refused (polygon and path) |
| equine | `the_equine_draft_shows_every_marker_on_the_phone_preview` passes; `the_equine_threshold_falls_on_the_caudal_zone_then_the_junctions`: × 1.235 accepted, × 1.24 the caudal zone alone (failures `[marker_interior_too_small]`), × 1.25 with the three junctions |
| `interior` unit tests | square, pentagram under both rules, forth and back, two opposite loops, deviation taken off, stop and floor, budget shared and spent, 60 random polygons (self-intersecting included) under both rules: never wider than a dense grid, every rim point filled |
| `path` unit tests | 300 random cubics, quadratics and arcs: every curve point within the recorded deviation of its chords, the deviation within 0.05 unless capped (arcs whose radii the endpoints scale up); closepath restarts at the subpath start; vertex cap |
Browsers (`apps/app/e2e/ui/interior-clicks.spec.ts`, the six click projects: Chromium 1280, 375 and 320 touch, Firefox
1280, WebKit 1280 and 375 touch; 90 passed, and `canvas-clicks.spec.ts` 99 unchanged). The probe
(`e2e/fixtures/interior-probe.json`, written and drift-checked by `tests/interior_probe.rs`) gives 14 shapes in the
preview's 286 × 310 box (one unit per CSS px) with the core's verdict and widest disc. For each, the browser's own fill
(`pointer-events="fill"`, stroke out) is sampled every 0.25 px and its widest disc taken by an exact distance transform:
the core never claims more than the browser fills (at most 0.5 px under it); the 8 refused fill no 4 px disc in any
engine; the 6 accepted take a real click or tap at the core's centre and the hit test at 32 points of 90 % of its radius,
fill only and as shipped. A drawing root `fill-rule="evenodd"` leaves the pentagram filled at its centre (isolation).
Then the equine shapes in the canvas: the core's disc hit test-clear (samples under a point's disc aside, at most a
quarter), and a real press where the fill lies farthest from every disc records the zone.
Chromium's touch adjustment, measured (tool `.claude/audits/2026-11-01-v1-2-2-interior-tools/`, taps every 2 px of each
equine zone's own hit area, 400 ms apart): a tap up to about 10 px around a point's disc goes to the point on
`chromium-320` and `chromium-375`, not on `webkit-375`. Taps recorded as the zone at 320 px: caudal 18/21, sacral 51/67,
lumbar 87/104, thoracic 72/97, cervical 195/195, trigger 278/284 (the rest to the neighbouring junctions and points, or to
nothing at the edges); WebKit 375: 91 to 99 %. Every equine zone keeps a tappable interior; near a point, Chromium's
targeting goes to the point, a browser behaviour the measure does not model (no selection redesign in V1-2.2).
Known limitation (owner, 2026-11-01, LOW accepted): a visible disc covering another marker entirely, or the only
interior of a zone, takes its taps; no rule refuses it. The human review identifies overlapping markers before a sheet
is published; no proof here claims that every marker is individually selectable when two overlap entirely. The arc
rotation reduced in `f32` by browsers (sub-pixel, §12.13) stays bounded by the `2²⁰` number bound, its tests kept.
Mutations (`.claude/audits/2026-11-01-v1-2-2-mutations-interior.py`): 24 killed, Z22 (the floor prune removed) survives
as equivalent, a cell that cannot reach the floor never holding an accepted disc; S1, S8 and F16 of the previous scripts,
whose anchors moved, re-anchored and killed. Module 579 180 B gzip -9 (+4 946 B, budget 600 000, margin 20 820 B).
Ignored cargo tests: the three are one test, `pdf_serialize::l_report_with_real_rasters_costs_what_it_costs`, counted
once per cargo run whose features build `pdf_serialize` (workspace, `cli`, `ts,pdf-read,pdf-write`). A timing print for
§10.7, 40 s in debug; run on request in release (2026-11-01: passed, 120 views, 46.5 MB, 5.2 s). The L report's export
itself is covered unignored (`pdf_budget`); it masks no required scenario.
@@ -1048,6 +1048,7 @@ Four stages, each a superset of the previous:
| Every reachable drawing present, size and sha256 equal to its row, read without removal, in the stored form of §9.2 | yes | | | `verification.integrity.*` | | Every reachable drawing present, size and sha256 equal to its row, read without removal, in the stored form of §9.2 | yes | | | `verification.integrity.*` |
| Every annotation entirely inside the frame of its view, edges included: the view's `view_box`, else the `viewBox` of the drawing it draws, read as a browser reads it (four numbers, positive width and height) and usable within the range rules browsers draw faithfully (owner brief 2026-11-01: edges within 2²⁰, spans from 1 unit, aspect at most 100, farthest edge at most 256 smaller spans); curves and arcs measured on their shape; path data a browser would not read whole refused; a view drawn on a clean drawing without either has no frame. Measured on the views whose drawing reads clean; the document is never rewritten (owner brief 2026-10-30, RUST.md §12.11) | yes | | | `verification.validation.out_of_frame` (issues `annotation.geometry.out_of_frame`, `view.frame.unknown`) | | Every annotation entirely inside the frame of its view, edges included: the view's `view_box`, else the `viewBox` of the drawing it draws, read as a browser reads it (four numbers, positive width and height) and usable within the range rules browsers draw faithfully (owner brief 2026-11-01: edges within 2²⁰, spans from 1 unit, aspect at most 100, farthest edge at most 256 smaller spans); curves and arcs measured on their shape; path data a browser would not read whole refused; a view drawn on a clean drawing without either has no frame. Measured on the views whose drawing reads clean; the document is never rewritten (owner brief 2026-10-30, RUST.md §12.11) | yes | | | `verification.validation.out_of_frame` (issues `annotation.geometry.out_of_frame`, `view.frame.unknown`) |
| Every annotation in frame shows at least 4 CSS px on the smallest preview, the editor at 320 × 568 (main view box 286 × 310, detail view box 254 × 191, `xMidYMid meet`): a point's visible disc (`2 × max(2, r − 12)`), a trigger circle's diameter, a polygon's or a path's smaller side (curves and arcs on their shape). Same views, same frame; the document is never rewritten (owner brief 2026-11-01, RUST.md §12.13) | yes | | | `verification.validation.marker_too_small` (issue `annotation.geometry.too_small`) | | Every annotation in frame shows at least 4 CSS px on the smallest preview, the editor at 320 × 568 (main view box 286 × 310, detail view box 254 × 191, `xMidYMid meet`): a point's visible disc (`2 × max(2, r − 12)`), a trigger circle's diameter, a polygon's or a path's smaller side (curves and arcs on their shape). Same views, same frame; the document is never rewritten (owner brief 2026-11-01, RUST.md §12.13) | yes | | | `verification.validation.marker_too_small` (issue `annotation.geometry.too_small`) |
| Every polygon or path annotation in frame fills a disc of 4 CSS px on the same preview: under the `nonzero` rule the layer fills with, its stroke left out, a centre inside the fill at least the radius from every edge (closing edges included), curves and arcs cut into chords whose deviation is taken off; measured within `interior::MAX_OUTLINE_VERTICES` 4 096 vertices and one budget of `2²⁵` edge distances per sheet, refused past them; refused in doubt (owner brief « fermeture du dernier MEDIUM » 2026-11-01, RUST.md §12.14) | yes | | | `verification.validation.marker_interior_too_small` (issue `annotation.geometry.interior_too_small`) |
| Fingerprint computed | yes | | | `verification.integrity.fingerprint` | | Fingerprint computed | yes | | | `verification.integrity.fingerprint` |
| Verdict passed, on the current revision | | yes | yes | `verdict.missing`, `verdict.failed`, `verdict.stale` | | Verdict passed, on the current revision | | yes | yes | `verdict.missing`, `verdict.failed`, `verdict.stale` |
| No `to_confirm` element (D2) | | yes | yes | `publish.to_confirm.open` | | No `to_confirm` element (D2) | | yes | yes | `publish.to_confirm.open` |