@rig-c/parts 2.47.1 → 2.48.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/docs/AUTHORING.md +132 -67
- package/docs/STABILITY.md +71 -28
- package/package.json +1 -1
- package/src/behindseams.ts +194 -91
- package/src/check.ts +2 -0
package/docs/AUTHORING.md
CHANGED
|
@@ -6396,8 +6396,8 @@ outside the consumed inputs pending [#1177](https://github.com/rig-c/parts/issue
|
|
|
6396
6396
|
| <a id="CHECK_SETUP_PAINTING_MEASURED"></a>`CHECK_SETUP_PAINTING_MEASURED` | missing native setup/ownership or unsupported clipping | supply observable textured setup geometry; an unavailable instrument never passes |
|
|
6397
6397
|
| <a id="CHECK_BOUNDARY_COLOUR_STEP"></a>`CHECK_BOUNDARY_COLOUR_STEP` | the requirements file declares `boundary_colour.max_step_excess` and a part boundary's colour step in the rig's render exceeds the same boundary's step in the rig's own pieces by more than it; the part pair, the frame (`setup` or `idle frame <n> (t <s> s)`), the stage pixel, the excess, the declared allowance and both steps are quoted. Unlike [`CHECK_SETUP_MATCHES_PAINTING`](#CHECK_SETUP_MATCHES_PAINTING), which compares the painting per declared region at the setup pose, this compares against the rig's own flat pieces (`parts.json` placement at setup, each piece's rest colour through its art UVs on every idle frame), so a part drawn over its neighbour's line art is not a failure | the pair's rig image or mesh: `rig/images/<part>.png` (a texture stretched into its padded UVs, or a notch cut out of it), or that part's mesh in `config.json` `meshes` when the mesh cuts a corner off the art; see [Boundary colour step](#boundary-colour-step-issue-942) |
|
|
6398
6398
|
| <a id="CHECK_BOUNDARY_COLOUR_UNMEASURED"></a>`CHECK_BOUNDARY_COLOUR_UNMEASURED` | `boundary_colour` is declared and the step cannot be taken: no `parts.json`, no `idle`, or a default-skin region or mesh image without a sequence, with a parts record, whose rig image is not its parts PNG with one even pad on every side (refused before anything is built); otherwise a drawn slot has no `parts.json` piece, is clipped, or its rig image is not its parts PNG with one even pad on every side (the slot and frame are named). Never a pass | make every drawn slot a `parts.json` piece, or drop `boundary_colour` from the requirements file (the bar then reports SKIP) |
|
|
6399
|
-
| <a id="CHECK_BEHIND_PART_SEAMS"></a>`CHECK_BEHIND_PART_SEAMS` | `behind_seams` is declared and a selected pair exceeds its allowance in the independent
|
|
6400
|
-
| <a id="CHECK_BEHIND_PART_SEAMS_UNMEASURED"></a>`CHECK_BEHIND_PART_SEAMS_UNMEASURED` | a pair with an authored effective threshold cannot read a mandatory population: selected pair, eligible behind slots, idle, readable setup, motion support, boundary population, or verified render/grid/material evidence; mandatory unread evidence makes the combined line FAIL. A missing threshold alone is a nonrequired SKIP and HOLE without this refusal code | supply the named measurement evidence
|
|
6399
|
+
| <a id="CHECK_BEHIND_PART_SEAMS"></a>`CHECK_BEHIND_PART_SEAMS` | `behind_seams` is declared and a selected pair exceeds its allowance in the independent `motion_opened` reading on an idle frame, in the `standing` reading at setup (compared against the parts' flat recomposite at their painted positions), or in either reading at an opted-in named turn pose; the pair, behind slots, reading, frame, counted seam cells and allowance are named | repair the declared seam in `parts/<part>.png` or `config.json` (`regions`, `meshes`, or `bones`), or author its allowance in `requirements.json` (`behind_seams.allowance` or `behind_seams.pairs[].allowance`); no WARN mode or rest-visible mask; see [Behind-part seams](#behind-part-seams-issue-1314) |
|
|
6400
|
+
| <a id="CHECK_BEHIND_PART_SEAMS_UNMEASURED"></a>`CHECK_BEHIND_PART_SEAMS_UNMEASURED` | a pair with an authored effective threshold cannot read a mandatory population: selected pair, eligible behind slots, `--parts` manifest (`parts.json` and `parts/*.png`) for setup standing's flat recomposite, idle, readable setup, motion support, boundary population, or verified render/grid/material evidence; mandatory unread evidence makes the combined line FAIL. A missing threshold alone is a nonrequired SKIP and HOLE without this refusal code | for the detail `no --parts manifest was supplied; setup standing compares the setup render with the parts' flat recomposite`, supply `parts.json` and `parts/<part>.png` (or pass `--parts <dir>` on the `rig-parts check` command line). For the detail `standing endpoints include ambiguous half-alpha owners`, the line names the case and, for each case, the first endpoint in scan order with both members' alpha: *neither* member reaches 128/255 there (both members' soft edges paint the same cell, each below 128/255) or *both* do (the members' overlap reaches the gap's edge). Edit `parts/<part>.png` of one member, or its source layer, so that exactly one member reaches 128/255 at that endpoint and the other is below it or does not paint it; the corridor is then read and may fail [`CHECK_BEHIND_PART_SEAMS`](#CHECK_BEHIND_PART_SEAMS) on a real gap. A threshold at or above the cell's distance to the recomposite removes the cell from the reading altogether; the threshold decides what could count; it does not clear a cell that could. `requirements.json` `behind_seams.allowance` never clears an unread cell; removing `behind_seams.threshold` (or `behind_seams.pairs[].threshold`), or the pair from `behind_seams.pairs[]` in `requirements.json`, only silences the reading (issues #1405, #1408). For any other detail, supply the named measurement evidence in `parts/<part>.png`, `config.json` or `requirements.json` `behind_seams`; an invalid selected-pair override in `requirements.json` `behind_seams.pairs[]` also refuses by name, and existing renderer or sidecar refusals remain refusals |
|
|
6401
6401
|
| <a id="SETUP_PAINTING_REQUIRED_LIMIT"></a>`SETUP_PAINTING_REQUIRED_LIMIT` | `setup_painting.required` is `true` and a limit the check needs is absent: `rgb_tolerance`, `regions`, or a region's `max_pixels` (the object names the region). Refused when the requirements file is read, before anything is built (issue #943) | author the named limit; none is derived from the art. Without `required` the same region reports SKIP |
|
|
6402
6402
|
| <a id="CHECK_SOURCE_GRID"></a>`CHECK_SOURCE_GRID` | the setup-pose still and its black-tinted twin (the coverage `SETUP_POSE_VS_SOURCE` reads) did not come back on one grid over one opaque background | a rigc problem; report it |
|
|
6403
6403
|
| <a id="CHECK_RIGC_VERSION"></a>`CHECK_RIGC_VERSION` | `rigc --version` is below 1.4.0, or prints no version: its `render` has no `--geometry`, which `TEXTURE_STRETCH` reads. Refused before anything is built | `bun install` (this package depends on rig-c ^2.20.4), or put a newer `rigc` first on `PATH` |
|
|
@@ -8372,24 +8372,74 @@ it does not uniquely attribute a defect to one rear slot.
|
|
|
8372
8372
|
The two readings are independent:
|
|
8373
8373
|
|
|
8374
8374
|
- `motion_opened` attributes core's stock transported setup-overlap
|
|
8375
|
-
`gapCovered` cells to that behind set
|
|
8376
|
-
|
|
8377
|
-
|
|
8378
|
-
|
|
8379
|
-
|
|
8380
|
-
|
|
8381
|
-
|
|
8382
|
-
|
|
8383
|
-
|
|
8384
|
-
|
|
8385
|
-
|
|
8386
|
-
|
|
8387
|
-
|
|
8388
|
-
|
|
8389
|
-
|
|
8390
|
-
|
|
8391
|
-
|
|
8392
|
-
|
|
8375
|
+
`gapCovered` cells to that behind set on every idle frame (and at opted-in
|
|
8376
|
+
turn poses). Its ordinary all-behind-hidden counterfactual must be
|
|
8377
|
+
transparent at the exact seam-cell centre, and setup attribution must show A
|
|
8378
|
+
or B covering that material. It uses no one-cell floor. A rigidly translated
|
|
8379
|
+
closed pair stays closed; no setup overlap band means this half is unmeasured
|
|
8380
|
+
on idle.
|
|
8381
|
+
- `standing` is measured at `setup` against the parts' flat recomposite at their
|
|
8382
|
+
painted positions (issue #1408), and at opted-in turn poses
|
|
8383
|
+
(`behind_seams.turn: true`) by pose endpoint contrast alone. At `setup`, it
|
|
8384
|
+
scans row and column runs whose combined A/B alpha is below 128/255, bracketed
|
|
8385
|
+
immediately by different unambiguous A/B owners (`1` and `2`), and compares
|
|
8386
|
+
the full setup render at each cell with the parts' flat recomposite
|
|
8387
|
+
(`flatComposite` of `parts.json` and `parts/*.png` over white in `rig.json`
|
|
8388
|
+
slot order, rendered onto the pair's native seam grid) when both are
|
|
8389
|
+
flattened source-over white (`[255, 255, 255]`). A cell is geometric when the
|
|
8390
|
+
behind set has positive surviving source-over contribution; it is raw
|
|
8391
|
+
(`raw_px`) when its straight rear RGB differs from both endpoint neighbours
|
|
8392
|
+
(`d[0] > 0` and `d[1] > 0`) and the full setup render's white-flattened RGB
|
|
8393
|
+
differs from the white-flattened parts' recomposite (`dRecomposite > 0`); it
|
|
8394
|
+
counts (`px`) when both endpoint distances and the recomposite distance
|
|
8395
|
+
strictly exceed the effective threshold T (`d[0] > T`, `d[1] > T` and
|
|
8396
|
+
`dRecomposite > T`, in max-channel distance). A cell outside the recomposite's
|
|
8397
|
+
canvas (`alpha === 0` on the rendered recomposite plate) is not excused
|
|
8398
|
+
(`dRecomposite = Infinity`). Equal-colour antialias ramps count zero contrast,
|
|
8399
|
+
and later opaque art — or any intervening or behind part already visible in
|
|
8400
|
+
the parts' recomposite at their painted positions — contributes zero
|
|
8401
|
+
recomposite difference. On a corridor whose endpoint owner is ambiguous
|
|
8402
|
+
(`0` or `3`) at setup, cells within T of the recomposite (`dRecomposite <= T`)
|
|
8403
|
+
are left out of the unread population, without adding their endpoints to
|
|
8404
|
+
`boundary_cells` (`support`), so a corridor whose cells all match the
|
|
8405
|
+
recomposite within T is not unread; elsewhere they stay geometric (`geometric_px`
|
|
8406
|
+
and `samples`) but cannot count (a threshold at or above the cell's distance
|
|
8407
|
+
to the recomposite removes the cell from the reading altogether; the
|
|
8408
|
+
threshold decides what could count; it does not clear a cell that could, and
|
|
8409
|
+
`allowance` never clears an unread cell). An ambiguous endpoint makes a
|
|
8410
|
+
corridor unread only when at least one of its cells differs from the
|
|
8411
|
+
recomposite by more than T (`dRecomposite > T`). Other readable corridors on
|
|
8412
|
+
that frame retain their measured cells. A counted total above allowance stays
|
|
8413
|
+
FAIL even when another corridor is unread; an unread population cannot turn a
|
|
8414
|
+
measured failure into SKIP. With unread corridors and no measured excess,
|
|
8415
|
+
standing is SKIP, never PASS. Without `--parts` (`parts.json` and
|
|
8416
|
+
`parts/*.png`), setup standing is `SKIP` with
|
|
8417
|
+
`reason: "no --parts manifest was supplied; setup standing compares the setup render with the parts' flat recomposite"`,
|
|
8418
|
+
records a `setup` `unmeasured[]` row, and with an authored T emits
|
|
8419
|
+
[`CHECK_BEHIND_PART_SEAMS_UNMEASURED`](#CHECK_BEHIND_PART_SEAMS_UNMEASURED).
|
|
8420
|
+
On idle frames, `standing` is never measured: where a frame's `motion_opened`
|
|
8421
|
+
is read, `frames[].standing` reports `SKIP` with
|
|
8422
|
+
`reason: "not applicable: motion_opened reads the pair"`, zero counts,
|
|
8423
|
+
`box: null`, `samples: []`, no unread fields, and no idle standing problem or
|
|
8424
|
+
unmeasured row; where a frame's `motion_opened` cannot be read,
|
|
8425
|
+
`frames[].standing` reports `SKIP` with
|
|
8426
|
+
`reason: "idle standing is not measured: idle frames have no recomposite oracle, and the pair's idle reading is motion_opened"`
|
|
8427
|
+
while `motion_opened` records its named `HOLE` (and `pairs[].standing`
|
|
8428
|
+
carries the pair's idle summary reason). This bracketed-run definition does
|
|
8429
|
+
not certify curved or diagonal openings.
|
|
8430
|
+
|
|
8431
|
+
Setup standing in `BEHIND_PART_SEAMS` measures whether the rig's setup pose
|
|
8432
|
+
places a selected front pair A/B away from where its parts were painted in
|
|
8433
|
+
`parts.json` and `parts/*.png`, opening a gap over `behind_slots` that was not
|
|
8434
|
+
in the parts' flat recomposite (`8-apart`). Because its oracle is the parts'
|
|
8435
|
+
flat recomposite at their painted positions rather than the `--source`
|
|
8436
|
+
painting, an intervening third part painted between A and B (`7a`), a distant
|
|
8437
|
+
foot or notch across an open silhouette (`7b`), or a half-alpha rear fringe
|
|
8438
|
+
already present in the parts' flat stack reads zero at setup without needing
|
|
8439
|
+
`--source`, and without failing on differences between the parts and the
|
|
8440
|
+
original painting. Fidelity to the `--source` painting is not setup standing's
|
|
8441
|
+
job: fidelity to the painting is [`SETUP_MATCHES_PAINTING`](#CHECK_SETUP_MATCHES_PAINTING)'s
|
|
8442
|
+
and the `RECOMPOSITE_HOLES` / `parts.json` `recomposite` record's job.
|
|
8393
8443
|
|
|
8394
8444
|
Both readings use core's public `seamGridOf` from `@rig-c/core/seam` and its
|
|
8395
8445
|
official raster traversal. The full
|
|
@@ -8398,31 +8448,45 @@ constraints, physics, environment and viewport; the hidden render does not
|
|
|
8398
8448
|
combine `--hide` with `--seam`. A viewport match alone is not a seam-grid proof.
|
|
8399
8449
|
Cells join by world centre and cell side, never by nearest image pixel.
|
|
8400
8450
|
|
|
8401
|
-
The report keeps `setup` separate from idle. Setup standing
|
|
8402
|
-
|
|
8403
|
-
|
|
8404
|
-
|
|
8405
|
-
|
|
8406
|
-
|
|
8407
|
-
|
|
8408
|
-
|
|
8409
|
-
|
|
8410
|
-
|
|
8411
|
-
|
|
8412
|
-
|
|
8451
|
+
The report keeps `setup` separate from idle. Setup standing lives at
|
|
8452
|
+
`pairs[].setup.standing` (`object: "pair \"<A>|<B>\" setup standing"` on
|
|
8453
|
+
excess); setup motion-opened is zero by definition only if setup was read.
|
|
8454
|
+
`pairs[].standing` describes the idle summary only (`status: "SKIP"` with the
|
|
8455
|
+
applicable idle `reason`), without folding setup into it, so a pair with setup
|
|
8456
|
+
`PASS 0`, `motion_opened` `PASS`, and not-applicable idle standing reads
|
|
8457
|
+
`PASS`. Rows name the pair, declaration provenance, animation, `behind_slots`,
|
|
8458
|
+
grid and sampled/read/unmeasured frame counts. The `motion_opened` reading
|
|
8459
|
+
retains per-frame hits (`index`, `time`, `px`, `cell`, `area`, `box`),
|
|
8460
|
+
`max_px`, the earliest worst hit and contiguous `spans`; the idle `standing`
|
|
8461
|
+
summary (`pairs[].standing`) is always `SKIP` with its `reason`, zero counts,
|
|
8462
|
+
`worst: null`, and empty `frames` and `spans` (while setup standing at
|
|
8463
|
+
`pairs[].setup.standing` and turn standing poses retain their measured counts,
|
|
8464
|
+
`box` and `samples`).
|
|
8465
|
+
`max_run` is temporal, in frames and seconds; `max_spatial_run_cells` is the
|
|
8466
|
+
longest counted horizontal/vertical run, with world length equal to cells times
|
|
8467
|
+
cell side. Counts named `px` are seam cells; rig-pixel area is count times cell
|
|
8468
|
+
side squared. Geometric rear-visible, raw contrast and threshold-filtered
|
|
8469
|
+
counts remain distinct. Overlapping pair counts are not a unique whole-rig
|
|
8470
|
+
area.
|
|
8413
8471
|
|
|
8414
8472
|
Issue #1325 adds optional unread-corridor evidence to the per-frame `standing`
|
|
8415
|
-
record
|
|
8416
|
-
`
|
|
8417
|
-
|
|
8418
|
-
|
|
8419
|
-
|
|
8420
|
-
|
|
8421
|
-
|
|
8473
|
+
record at `BEHIND_PART_SEAMS.pairs[].setup.standing` (and on turn standing
|
|
8474
|
+
frames when `behind_seams.turn: true`; idle `frames[].standing` is never
|
|
8475
|
+
measured). The fields below are relative to that record. They describe
|
|
8476
|
+
bracketed low-alpha runs with an endpoint owner of 0 or 3 that have at least
|
|
8477
|
+
one cell differing from the parts' recomposite by more than T at setup
|
|
8478
|
+
(`dRecomposite > T`); they do not infer an owner or count those runs as
|
|
8479
|
+
measured contrast. At setup, `unread_corridors[].cells`, `cell_count` and
|
|
8480
|
+
`unread_cells` leave out cells within T of the recomposite (`dRecomposite <= T`)
|
|
8481
|
+
and report the remaining interior cells of the run, excluding its endpoints,
|
|
8482
|
+
whether or not rear colour would qualify against endpoint contrast T (on turn
|
|
8483
|
+
poses, which have no recomposite oracle, all interior cells of the run are
|
|
8484
|
+
reported). A cell can be unread on one axis and readable on the other; unread
|
|
8485
|
+
evidence does not remove a measured hit.
|
|
8422
8486
|
|
|
8423
8487
|
| Field | Contract |
|
|
8424
8488
|
| --- | --- |
|
|
8425
|
-
| `unread_cells` | Optional positive integer: the number of distinct native grid cells in all unread corridors of this frame. Cross-axis intersections count once; this is not a sum of `cell_count` values or a measured defect count. |
|
|
8489
|
+
| `unread_cells` | Optional positive integer: the number of distinct native grid cells in all unread corridors of this frame (at setup, leaving out cells within T of the parts' recomposite). Cross-axis intersections count once; this is not a sum of `cell_count` values or a measured defect count. |
|
|
8426
8490
|
| `unread_corridors` | Optional nonempty array. Horizontal corridors come first, in top-to-bottom row and left-to-right run order; vertical corridors follow, in left-to-right column and top-to-bottom run order. |
|
|
8427
8491
|
| `unread_corridors[].axis` | `horizontal` for a row run, `vertical` for a column run. |
|
|
8428
8492
|
| `unread_corridors[].endpoints` | Two numeric tuples in spatial order: left/right for horizontal, top/bottom for vertical. They are not reordered into A/B ownership order. Each tuple is `[grid_x, grid_y, world_x, world_y, owner]`. |
|
|
@@ -8431,8 +8495,8 @@ and readable on the other; unread evidence does not remove a measured hit.
|
|
|
8431
8495
|
| `unread_corridors[].endpoints[][2]` | World-space x coordinate of the endpoint cell centre. |
|
|
8432
8496
|
| `unread_corridors[].endpoints[][3]` | World-space y coordinate of the endpoint cell centre, y up. |
|
|
8433
8497
|
| `unread_corridors[].endpoints[][4]` | Observed half-alpha owner code: 0 means neither A nor B reaches 128/255; 1 means only A does; 2 means only B does; 3 means both do. A and B are the selected pair's named members; 0 and 3 are not resolved by guessing. |
|
|
8434
|
-
| `unread_corridors[].cells` | Interior native-cell centres as numeric `[world_x, world_y]` tuples, y up, left-to-right or top-to-bottom along the run. A centre may occur in multiple corridors. |
|
|
8435
|
-
| `unread_corridors[].cell_count` | The number of interior cells in this corridor, exactly `cells.length`. |
|
|
8498
|
+
| `unread_corridors[].cells` | Interior native-cell centres as numeric `[world_x, world_y]` tuples, y up, left-to-right or top-to-bottom along the run, leaving out cells within T of the parts' recomposite at setup (on turn poses, all interior cells of the run). A centre may occur in multiple corridors. |
|
|
8499
|
+
| `unread_corridors[].cell_count` | The number of reported interior cells in this corridor (at setup, leaving out cells within T of the recomposite), exactly `cells.length`. |
|
|
8436
8500
|
| `unread_corridors[].row_scope` | `pair`; the corridor observes the selected front pair, not an individual rear slot. |
|
|
8437
8501
|
| `unread_corridors[].row_kind` | `evidence`, including when the required check fails. |
|
|
8438
8502
|
| `unread_corridors[].row_subjects` | The two selected part names in producer A/B order. |
|
|
@@ -8445,19 +8509,20 @@ unmeasured handling; absence of these optional fields alone does not prove a
|
|
|
8445
8509
|
fully read frame.
|
|
8446
8510
|
|
|
8447
8511
|
`sampled_frames`, `read_frames` and `unmeasured_frames` count idle frames only.
|
|
8448
|
-
|
|
8449
|
-
|
|
8450
|
-
|
|
8451
|
-
separately and is not counted as an idle frame.
|
|
8512
|
+
An idle frame enters `read_frames` when `motion_opened` is read on that frame;
|
|
8513
|
+
when `motion_opened` is unavailable on that frame, the frame enters
|
|
8514
|
+
`unmeasured_frames` (idle `standing` is never measured). Setup is reported
|
|
8515
|
+
separately at `pairs[].setup` and is not counted as an idle frame.
|
|
8452
8516
|
|
|
8453
8517
|
A measured count above the effective allowance is
|
|
8454
8518
|
[`CHECK_BEHIND_PART_SEAMS`](#CHECK_BEHIND_PART_SEAMS). A pair without an
|
|
8455
8519
|
effective T reports a nonrequired SKIP and HOLE; missing T alone emits no
|
|
8456
8520
|
`CHECK_BEHIND_PART_SEAMS_UNMEASURED` problem and cannot establish a behind-part
|
|
8457
|
-
PASS. With authored T, missing behind slots,
|
|
8458
|
-
|
|
8459
|
-
|
|
8460
|
-
|
|
8521
|
+
PASS. With authored T, missing behind slots, `--parts` manifest for setup
|
|
8522
|
+
standing's recomposite, idle, setup, motion support, boundary population or
|
|
8523
|
+
verified render/material evidence cannot establish PASS. An unavailable reading
|
|
8524
|
+
is SKIP; a partially unread setup (or turn) standing reading retains any
|
|
8525
|
+
measured FAIL as described above. An unread population reports a HOLE and emits
|
|
8461
8526
|
[`CHECK_BEHIND_PART_SEAMS_UNMEASURED`](#CHECK_BEHIND_PART_SEAMS_UNMEASURED),
|
|
8462
8527
|
making the combined line FAIL. Existing hard render and sidecar failures
|
|
8463
8528
|
remain named refusals. Setup-only or partial readings cannot establish the
|
|
@@ -9539,18 +9604,18 @@ Internal `SeamSupport.drawings` never enters check JSON. Named requirement
|
|
|
9539
9604
|
| `ANIMATIONS_DO_NOT_FOLD.declared_not_folding` | `ANIMATIONS_DO_NOT_FOLD.declared_not_folding` | part when the supplied mapping resolves a piece; otherwise rig | finding | resolved piece for e.slot; otherwise [] | [check.ts:3697](../src/check.ts#L3697) |
|
|
9540
9605
|
| `ANIMATIONS_DO_NOT_FOLD.folding` | `ANIMATIONS_DO_NOT_FOLD.folding` | part when the supplied mapping resolves a piece; otherwise rig | finding when entry === undefined; otherwise evidence | resolved piece for slot; otherwise [] | [check.ts:3659](../src/check.ts#L3659) |
|
|
9541
9606
|
| `ART_JOINT_DISTANCE.joints` | `ART_JOINT_DISTANCE.joints` | 'rig' | finding when status === 'FAIL'; otherwise evidence | [] | [artjoints.ts:86](../src/artjoints.ts#L86) |
|
|
9542
|
-
| `BEHIND_PART_SEAMS.contributors` | `BEHIND_PART_SEAMS.turn.pairs[].frames[].standing.samples[].contributors`; `BEHIND_PART_SEAMS.turn.pairs[].frames[].motion_opened.samples[].contributors`; `BEHIND_PART_SEAMS.pairs[].setup.motion_opened.samples[].contributors`; `BEHIND_PART_SEAMS.pairs[].setup.standing.samples[].contributors`; `BEHIND_PART_SEAMS.pairs[].frames[].motion_opened.samples[].contributors`; `BEHIND_PART_SEAMS.pairs[].frames[].standing.samples[].contributors` | 'pair' | evidence | [pair.a, pair.b] | [behindseams.ts:
|
|
9543
|
-
| `BEHIND_PART_SEAMS.hits` | `BEHIND_PART_SEAMS.pairs[].motion_opened.frames`; `BEHIND_PART_SEAMS.pairs[].standing.frames`; `BEHIND_PART_SEAMS.pairs[].motion_opened.worst`; `BEHIND_PART_SEAMS.pairs[].standing.worst` | 'pair' | finding when r.px > allowance; otherwise evidence | parts | [behindseams.ts:
|
|
9544
|
-
| `BEHIND_PART_SEAMS.pairs` | `BEHIND_PART_SEAMS.pairs` | 'pair' | finding when failed; otherwise evidence | parts | [behindseams.ts:
|
|
9607
|
+
| `BEHIND_PART_SEAMS.contributors` | `BEHIND_PART_SEAMS.turn.pairs[].frames[].standing.samples[].contributors`; `BEHIND_PART_SEAMS.turn.pairs[].frames[].motion_opened.samples[].contributors`; `BEHIND_PART_SEAMS.pairs[].setup.motion_opened.samples[].contributors`; `BEHIND_PART_SEAMS.pairs[].setup.standing.samples[].contributors`; `BEHIND_PART_SEAMS.pairs[].frames[].motion_opened.samples[].contributors`; `BEHIND_PART_SEAMS.pairs[].frames[].standing.samples[].contributors` | 'pair' | evidence | [pair.a, pair.b] | [behindseams.ts:520](../src/behindseams.ts#L520) |
|
|
9608
|
+
| `BEHIND_PART_SEAMS.hits` | `BEHIND_PART_SEAMS.pairs[].motion_opened.frames`; `BEHIND_PART_SEAMS.pairs[].standing.frames`; `BEHIND_PART_SEAMS.pairs[].motion_opened.worst`; `BEHIND_PART_SEAMS.pairs[].standing.worst` | 'pair' | finding when r.px > allowance; otherwise evidence | parts | [behindseams.ts:597](../src/behindseams.ts#L597) |
|
|
9609
|
+
| `BEHIND_PART_SEAMS.pairs` | `BEHIND_PART_SEAMS.pairs` | 'pair' | finding when failed; otherwise evidence | parts | [behindseams.ts:682](../src/behindseams.ts#L682) |
|
|
9545
9610
|
| `BEHIND_PART_SEAMS.pairs[].frames` | `BEHIND_PART_SEAMS.pairs[].frames` | | | | |
|
|
9546
9611
|
| `BEHIND_PART_SEAMS.pairs[].setup` | `BEHIND_PART_SEAMS.pairs[].setup` | | | | |
|
|
9547
|
-
| `BEHIND_PART_SEAMS.samples` | `BEHIND_PART_SEAMS.turn.pairs[].frames[].standing.samples`; `BEHIND_PART_SEAMS.turn.pairs[].frames[].motion_opened.samples`; `BEHIND_PART_SEAMS.pairs[].setup.motion_opened.samples`; `BEHIND_PART_SEAMS.pairs[].setup.standing.samples`; `BEHIND_PART_SEAMS.pairs[].frames[].motion_opened.samples`; `BEHIND_PART_SEAMS.pairs[].frames[].standing.samples` | 'pair' | evidence | [pair.a, pair.b] | [behindseams.ts:
|
|
9548
|
-
| `BEHIND_PART_SEAMS.spans` | `BEHIND_PART_SEAMS.pairs[].motion_opened.spans`; `BEHIND_PART_SEAMS.pairs[].standing.spans` | 'pair' | evidence | parts | [behindseams.ts:
|
|
9549
|
-
| `BEHIND_PART_SEAMS.turn.pairs` | `BEHIND_PART_SEAMS.turn.pairs` | 'pair' | finding when required; otherwise evidence; finding when motion.status === 'FAIL' || standing.status === 'FAIL' || threshold !== null && read !== turn.poses.length; otherwise evidence | [pair.a, pair.b]; parts | [behindseams.ts:
|
|
9612
|
+
| `BEHIND_PART_SEAMS.samples` | `BEHIND_PART_SEAMS.turn.pairs[].frames[].standing.samples`; `BEHIND_PART_SEAMS.turn.pairs[].frames[].motion_opened.samples`; `BEHIND_PART_SEAMS.pairs[].setup.motion_opened.samples`; `BEHIND_PART_SEAMS.pairs[].setup.standing.samples`; `BEHIND_PART_SEAMS.pairs[].frames[].motion_opened.samples`; `BEHIND_PART_SEAMS.pairs[].frames[].standing.samples` | 'pair' | evidence | [pair.a, pair.b] | [behindseams.ts:519](../src/behindseams.ts#L519) |
|
|
9613
|
+
| `BEHIND_PART_SEAMS.spans` | `BEHIND_PART_SEAMS.pairs[].motion_opened.spans`; `BEHIND_PART_SEAMS.pairs[].standing.spans` | 'pair' | evidence | parts | [behindseams.ts:605](../src/behindseams.ts#L605) |
|
|
9614
|
+
| `BEHIND_PART_SEAMS.turn.pairs` | `BEHIND_PART_SEAMS.turn.pairs` | 'pair' | finding when required; otherwise evidence; finding when motion.status === 'FAIL' || standing.status === 'FAIL' || threshold !== null && read !== turn.poses.length; otherwise evidence | [pair.a, pair.b]; parts | [behindseams.ts:712](../src/behindseams.ts#L712), [behindseams.ts:754](../src/behindseams.ts#L754) |
|
|
9550
9615
|
| `BEHIND_PART_SEAMS.turn.pairs[].frames` | `BEHIND_PART_SEAMS.turn.pairs[].frames` | | | | |
|
|
9551
|
-
| `BEHIND_PART_SEAMS.turn.unmeasured` | `BEHIND_PART_SEAMS.turn.unmeasured` | pair === null ? 'rig' : 'pair' | finding when mandatory; otherwise evidence | pair === null ? [] : [pair.a, pair.b] | [behindseams.ts:
|
|
9552
|
-
| `BEHIND_PART_SEAMS.unmeasured` | `BEHIND_PART_SEAMS.unmeasured` | pair === null ? 'rig' : 'pair'; 'rig' | finding when required; otherwise evidence; finding | pair === null ? [] : [pair.a, pair.b]; [] | [behindseams.ts:
|
|
9553
|
-
| `BEHIND_PART_SEAMS.unread_corridors` | `BEHIND_PART_SEAMS.turn.pairs[].frames[].standing.unread_corridors`; `BEHIND_PART_SEAMS.pairs[].setup.standing.unread_corridors`; `BEHIND_PART_SEAMS.pairs[].frames[].standing.unread_corridors` | 'pair' | evidence | [pair.a, pair.b] | [behindseams.ts:
|
|
9616
|
+
| `BEHIND_PART_SEAMS.turn.unmeasured` | `BEHIND_PART_SEAMS.turn.unmeasured` | pair === null ? 'rig' : 'pair' | finding when mandatory; otherwise evidence | pair === null ? [] : [pair.a, pair.b] | [behindseams.ts:704](../src/behindseams.ts#L704) |
|
|
9617
|
+
| `BEHIND_PART_SEAMS.unmeasured` | `BEHIND_PART_SEAMS.unmeasured` | pair === null ? 'rig' : 'pair'; 'rig' | finding when required; otherwise evidence; finding | pair === null ? [] : [pair.a, pair.b]; [] | [behindseams.ts:618](../src/behindseams.ts#L618), [behindseams.ts:955](../src/behindseams.ts#L955), [behindseams.ts:1003](../src/behindseams.ts#L1003) |
|
|
9618
|
+
| `BEHIND_PART_SEAMS.unread_corridors` | `BEHIND_PART_SEAMS.turn.pairs[].frames[].standing.unread_corridors`; `BEHIND_PART_SEAMS.pairs[].setup.standing.unread_corridors`; `BEHIND_PART_SEAMS.pairs[].frames[].standing.unread_corridors` | 'pair' | evidence | [pair.a, pair.b] | [behindseams.ts:453](../src/behindseams.ts#L453) |
|
|
9554
9619
|
| `BOUNDARY_COLOUR_STEP.over` | `BOUNDARY_COLOUR_STEP.over` | 'pair' | finding | r.parts | [boundarycolour.ts:221](../src/boundarycolour.ts#L221) |
|
|
9555
9620
|
| `BOUNDARY_COLOUR_STEP.unmeasured` | `BOUNDARY_COLOUR_STEP.unmeasured` | part when the supplied mapping resolves a piece; otherwise rig | evidence | resolved piece for r.slot; otherwise [] | [boundarycolour.ts:222](../src/boundarycolour.ts#L222) |
|
|
9556
9621
|
| `CLOTH_SETTLES.rows` | `CLOTH_SETTLES.rows` | 'rig' | finding when speeds.length > 0 && s < speeds.length; otherwise evidence | [] | [check.ts:6144](../src/check.ts#L6144) |
|
|
@@ -9574,21 +9639,21 @@ Internal `SeamSupport.drawings` never enters check JSON. Named requirement
|
|
|
9574
9639
|
| `SEAM_OVER_RANGE.joints[].poses` | `SEAM_OVER_RANGE.joints[].poses` | 'part' | finding when fail; otherwise evidence | [j.part] | [check.ts:4558](../src/check.ts#L4558) |
|
|
9575
9640
|
| `SETUP_MATCHES_PAINTING.regions` | `SETUP_MATCHES_PAINTING.regions` | 'rig' | finding when status === 'FAIL'; otherwise evidence | [] | [setuppainting.ts:175](../src/setuppainting.ts#L175) |
|
|
9576
9641
|
| `SETUP_MATCHES_PAINTING.regions[].slots` | `SETUP_MATCHES_PAINTING.regions[].slots` | part when the supplied mapping resolves a piece; otherwise rig | evidence | resolved piece for slot; otherwise [] | [setuppainting.ts:176](../src/setuppainting.ts#L176) |
|
|
9577
|
-
| `STILL_REGIONS_DARK.*.crossing` | `STILL_REGIONS_DARK.*.crossing` | part when the supplied mapping resolves a piece; otherwise rig | finding | resolved piece for sl.name; otherwise [] | [check.ts:
|
|
9578
|
-
| `STILL_REGIONS_DARK.*.still_slots` | `STILL_REGIONS_DARK.*.still_slots` | part when the supplied mapping resolves a piece; otherwise rig | evidence; finding when r.max > tolerance; otherwise evidence | resolved piece for slot; otherwise [] | [check.ts:
|
|
9642
|
+
| `STILL_REGIONS_DARK.*.crossing` | `STILL_REGIONS_DARK.*.crossing` | part when the supplied mapping resolves a piece; otherwise rig | finding | resolved piece for sl.name; otherwise [] | [check.ts:9288](../src/check.ts#L9288) |
|
|
9643
|
+
| `STILL_REGIONS_DARK.*.still_slots` | `STILL_REGIONS_DARK.*.still_slots` | part when the supplied mapping resolves a piece; otherwise rig | evidence; finding when r.max > tolerance; otherwise evidence | resolved piece for slot; otherwise [] | [check.ts:9274](../src/check.ts#L9274), [check.ts:9279](../src/check.ts#L9279) |
|
|
9579
9644
|
| `STRESS_OFF_CHAIN.not_read` | `STRESS_OFF_CHAIN.not_read` | 'part' | evidence | [r.part] | [check.ts:4118](../src/check.ts#L4118) |
|
|
9580
9645
|
| `STRESS_OFF_CHAIN.per_part` | `STRESS_OFF_CHAIN.per_part` | 'part' | finding when poses.some(p => typeof p.reading === 'number' && p.reading > STRESS_RIGID); otherwise evidence | [r.part] | [check.ts:4106](../src/check.ts#L4106) |
|
|
9581
9646
|
| `STRESS_OFF_CHAIN.per_part[].off_chain` | `STRESS_OFF_CHAIN.per_part[].off_chain` | 'part' | evidence | [r.part] | [check.ts:4106](../src/check.ts#L4106) |
|
|
9582
9647
|
| `STRESS_OFF_CHAIN.per_part[].poses` | `STRESS_OFF_CHAIN.per_part[].poses` | 'part' | evidence; finding when shown > STRESS_RIGID; otherwise evidence | [r.part] | [check.ts:4074](../src/check.ts#L4074), [check.ts:4092](../src/check.ts#L4092) |
|
|
9583
|
-
| `TEXTURE_STRETCH.per_mesh` | `TEXTURE_STRETCH.per_mesh` | part when the supplied mapping resolves a piece; otherwise rig | evidence; finding when severity > TEXTURE_STRETCH_CEILING; otherwise evidence | resolved piece for m.slot; otherwise [] | [check.ts:
|
|
9584
|
-
| `TIP_OVER_ROOT.parts` | `TIP_OVER_ROOT.parts` | 'part' | evidence; finding when !ok && !(!rigid && hanging.onLink && Math.max(c.root, c.tip) < TIP_TRAVEL_FLOOR); otherwise evidence | [p.name] | [check.ts:
|
|
9648
|
+
| `TEXTURE_STRETCH.per_mesh` | `TEXTURE_STRETCH.per_mesh` | part when the supplied mapping resolves a piece; otherwise rig | evidence; finding when severity > TEXTURE_STRETCH_CEILING; otherwise evidence | resolved piece for m.slot; otherwise [] | [check.ts:9938](../src/check.ts#L9938), [check.ts:9948](../src/check.ts#L9948) |
|
|
9649
|
+
| `TIP_OVER_ROOT.parts` | `TIP_OVER_ROOT.parts` | 'part' | evidence; finding when !ok && !(!rigid && hanging.onLink && Math.max(c.root, c.tip) < TIP_TRAVEL_FLOOR); otherwise evidence | [p.name] | [check.ts:8663](../src/check.ts#L8663), [check.ts:8668](../src/check.ts#L8668), [check.ts:8689](../src/check.ts#L8689), [check.ts:8700](../src/check.ts#L8700) |
|
|
9585
9650
|
| `WIND_BAND.pairs` | `WIND_BAND.pairs` | 'pair' | finding when !holdsAll; otherwise evidence | [p.a, p.b] | [check.ts:6648](../src/check.ts#L6648) |
|
|
9586
9651
|
| `WIND_BAND.pairs[].steps` | `WIND_BAND.pairs[].steps` | 'pair' | finding when !s.holds; otherwise evidence | [p.a, p.b] | [check.ts:6659](../src/check.ts#L6659) |
|
|
9587
9652
|
| `figure_openings.openings` | `figure_openings.openings` | 'pair' | finding | [ps.under, ps.above] | [check.ts:5965](../src/check.ts#L5965) |
|
|
9588
|
-
| `loop_physics` | `loop_physics` | 'rig' | evidence | [] | [check.ts:
|
|
9589
|
-
| `requirements.lines.* (bone)` | `requirements.lines.*` | 'rig' | finding when line.status === 'FAIL'; otherwise evidence | [] | [check.ts:
|
|
9590
|
-
| `requirements.lines.* (seam)` | `requirements.lines.*` | 'pair' | finding when line.status === 'FAIL'; otherwise evidence | [r.part, r.neighbour] | [check.ts:
|
|
9591
|
-
| `requirements.lines.* (stretch)` | `requirements.lines.*` | part when the supplied mapping resolves a piece; otherwise rig | finding when line.status === 'FAIL'; otherwise evidence | resolved piece for r.slot; otherwise [] | [check.ts:
|
|
9653
|
+
| `loop_physics` | `loop_physics` | 'rig' | evidence | [] | [check.ts:7704](../src/check.ts#L7704) |
|
|
9654
|
+
| `requirements.lines.* (bone)` | `requirements.lines.*` | 'rig' | finding when line.status === 'FAIL'; otherwise evidence | [] | [check.ts:8031](../src/check.ts#L8031) |
|
|
9655
|
+
| `requirements.lines.* (seam)` | `requirements.lines.*` | 'pair' | finding when line.status === 'FAIL'; otherwise evidence | [r.part, r.neighbour] | [check.ts:8031](../src/check.ts#L8031) |
|
|
9656
|
+
| `requirements.lines.* (stretch)` | `requirements.lines.*` | part when the supplied mapping resolves a piece; otherwise rig | finding when line.status === 'FAIL'; otherwise evidence | resolved piece for r.slot; otherwise [] | [check.ts:8031](../src/check.ts#L8031) |
|
|
9592
9657
|
| `seam_cells.frames` | `frames` | 'pair' | evidence | [p.a, p.b] | [check.ts:4849](../src/check.ts#L4849) |
|
|
9593
9658
|
| `seam_cells.frames[].cells` | `frames[].cells` | part when the supplied mapping resolves a piece; otherwise rig | evidence | resolved piece for cell.setupTop ?? ''; otherwise [] | [check.ts:4809](../src/check.ts#L4809) |
|
|
9594
9659
|
| `seam_pairs` | `seam_pairs`; `seam_scope.whole_pairs`; `sets.*.seam_pairs`; `sets.*.seam_scope.whole_pairs` | subjects.length === 0 ? 'rig' : subjects.length === 1 ? 'part' : 'pair' | evidence | subjects | [check.ts:2548](../src/check.ts#L2548) |
|
package/docs/STABILITY.md
CHANGED
|
@@ -1575,22 +1575,59 @@ default, and a pair without either a rig or pair T reports SKIP and a HOLE,
|
|
|
1575
1575
|
never PASS. Allowance is a nonnegative safe integer, defaulting to 0 by the
|
|
1576
1576
|
explicit design ruling, with optional per-pair override for both halves.
|
|
1577
1577
|
|
|
1578
|
-
Declared readings independently measure motion-opened rear visibility
|
|
1579
|
-
standing contrasting rear visibility
|
|
1580
|
-
|
|
1581
|
-
|
|
1582
|
-
|
|
1583
|
-
|
|
1584
|
-
|
|
1585
|
-
|
|
1586
|
-
`
|
|
1587
|
-
|
|
1588
|
-
|
|
1578
|
+
Declared readings independently measure motion-opened rear visibility on every
|
|
1579
|
+
idle frame and standing contrasting rear visibility at setup (against the
|
|
1580
|
+
parts' flat recomposite at their painted positions, issue #1408) on core's
|
|
1581
|
+
official seam grid. There is no WARN mode, one-cell floor, rest mask or
|
|
1582
|
+
subtraction of setup-visible cells. At setup, `standing` compares the full setup
|
|
1583
|
+
render (`rasters.full`) with the parts' flat recomposite (`flatComposite` of
|
|
1584
|
+
`parts.json` and `parts/*.png` over white in `rig.json` slot order, rendered
|
|
1585
|
+
onto the pair's native seam grid), both flattened source-over white
|
|
1586
|
+
(`[255, 255, 255]`), by max-channel distance: a bracketed rear-visible cell is
|
|
1587
|
+
raw (`raw_px`) when `d[0] > 0`, `d[1] > 0` and `dRecomposite > 0`, and counts
|
|
1588
|
+
(`px`) when `d[0] > T`, `d[1] > T` and `dRecomposite > T` (a cell outside the
|
|
1589
|
+
recomposite's canvas has `dRecomposite = Infinity`). Setup standing catches a
|
|
1590
|
+
part that the rig places away from where it was painted; it does not measure
|
|
1591
|
+
fidelity to the `--source` painting (which is `SETUP_MATCHES_PAINTING`'s and the
|
|
1592
|
+
`RECOMPOSITE_HOLES` / `parts.json` `recomposite` record's job), and `--source`
|
|
1593
|
+
is not required for `behind_seams`. A recomposite whose size differs from the
|
|
1594
|
+
stage is refused by name and never resampled; and through `check` the loader
|
|
1595
|
+
refuses the same mismatch earlier, as `CHECK_RIG_STAGE_IS_THE_CANVAS`. On a
|
|
1596
|
+
corridor whose endpoint owner is ambiguous (`0` or `3`) at setup, cells within T
|
|
1597
|
+
of the recomposite (`dRecomposite <= T`) are left out of the unread population,
|
|
1598
|
+
without adding their endpoints to `boundary_cells` (`support`); elsewhere they
|
|
1599
|
+
stay geometric (`geometric_px` and `samples`) but cannot count. An ambiguous
|
|
1600
|
+
endpoint makes a corridor unread only when at least one of its cells differs
|
|
1601
|
+
from the recomposite by more than T (`dRecomposite > T`), and `allowance` never
|
|
1602
|
+
clears an unread cell. Without `--parts` (`parts.json` and `parts/*.png`), setup
|
|
1603
|
+
standing is `SKIP` with
|
|
1604
|
+
`reason: "no --parts manifest was supplied; setup standing compares the setup render with the parts' flat recomposite"`,
|
|
1605
|
+
adds a `setup` `unmeasured[]` row, and with an authored T emits
|
|
1606
|
+
`CHECK_BEHIND_PART_SEAMS_UNMEASURED`. On idle frames, `standing` is never
|
|
1607
|
+
measured: `frames[].standing` and `pairs[].standing` carry `status: "SKIP"` with
|
|
1608
|
+
`reason: "not applicable: motion_opened reads the pair"` when `motion_opened`
|
|
1609
|
+
reads that frame (or pair), or
|
|
1610
|
+
`reason: "idle standing is not measured: idle frames have no recomposite oracle, and the pair's idle reading is motion_opened"`
|
|
1611
|
+
when `motion_opened` cannot read that frame (or pair). `pairs[].standing` is
|
|
1612
|
+
the idle summary only; setup status is at `pairs[].setup.standing` (never folded
|
|
1613
|
+
into `pairs[].standing`), and `BehindSeamsStanding` and `BehindSeamsReading`
|
|
1614
|
+
carry an optional `reason` string when `status` is `"SKIP"`. `BEHIND_PART_SEAMS`
|
|
1615
|
+
keeps `setup`, `motion_opened` and `standing` separate, names the selected pair
|
|
1616
|
+
and provenance, per-frame `behind_slots`, grid and sampled/read/unmeasured
|
|
1617
|
+
counts, and reports per-frame hits, worst counts, temporal spans and spatial
|
|
1618
|
+
runs. Exceeding the allowance uses `CHECK_BEHIND_PART_SEAMS`
|
|
1619
|
+
(`object: "pair \"<A>|<B>\" setup standing"` at setup); a mandatory unread
|
|
1620
|
+
population uses `CHECK_BEHIND_PART_SEAMS_UNMEASURED`. Missing behind slots,
|
|
1621
|
+
`--parts` manifest for setup standing's recomposite, idle, setup, motion
|
|
1622
|
+
support, boundary population or verified render evidence is a HOLE, not a zero
|
|
1623
|
+
PASS. Existing render/sidecar refusals remain refusals. The standing
|
|
1589
1624
|
bracketed-run definition does not certify curved or diagonal openings.
|
|
1590
1625
|
|
|
1591
1626
|
Per-cell samples are a bounded diagnostic sample; the counts are the
|
|
1592
|
-
measurement (issue #1403). Each `samples[]` list (standing
|
|
1593
|
-
|
|
1627
|
+
measurement (issue #1403). Each measured `samples[]` list (setup standing, idle
|
|
1628
|
+
`motion_opened` on every idle frame, and turn `standing` and `motion_opened` on
|
|
1629
|
+
every turn pose; idle `standing` is never measured and its `samples[]` is always
|
|
1630
|
+
`[]`) holds at most 64 rows.
|
|
1594
1631
|
A list that measured more holds 64 and gains `samples_omitted`, the number of
|
|
1595
1632
|
rows left out; a list of 64 or fewer has no such field and is written as before.
|
|
1596
1633
|
Standing keeps its 64 worst rows: counted first, then the larger of the two
|
|
@@ -1610,7 +1647,10 @@ min/max corner, deduplicated in that order. It records planned and observed dial
|
|
|
1610
1647
|
spans: pose indices are sample identities, and time is 0 for every reset.
|
|
1611
1648
|
Turn uses its own setup, rest geometry and transported stock seam evidence;
|
|
1612
1649
|
idle stock and idle counts are unchanged. The same thresholds, allowances,
|
|
1613
|
-
rear-set and unread rules apply
|
|
1650
|
+
rear-set and endpoint-ownership unread rules apply, without a recomposite
|
|
1651
|
+
comparison (turn poses have no per-pose recomposite oracle, so turn standing is
|
|
1652
|
+
judged by endpoint contrast alone and reports all interior cells of an unread
|
|
1653
|
+
corridor). Optional unread-corridor evidence also applies
|
|
1614
1654
|
to turn standing rows. No declared dial persists turn SKIP and a named HOLE;
|
|
1615
1655
|
an effective authored T makes that missing required reading a
|
|
1616
1656
|
`CHECK_BEHIND_PART_SEAMS_UNMEASURED` failure. Legacy `turn.x` has no declared
|
|
@@ -1630,18 +1670,18 @@ An unavailable poser or source is a HOLE. Other animations, between-sample turns
|
|
|
1630
1670
|
skins remain unmeasured.
|
|
1631
1671
|
|
|
1632
1672
|
Issue #1325 adds the following optional evidence fields to
|
|
1633
|
-
`BEHIND_PART_SEAMS.pairs[].setup.standing` and
|
|
1634
|
-
`
|
|
1635
|
-
relative to that standing record.
|
|
1673
|
+
`BEHIND_PART_SEAMS.pairs[].setup.standing` (and turn standing records when
|
|
1674
|
+
`behind_seams.turn: true`; idle `frames[].standing` is never measured). Paths in
|
|
1675
|
+
the table are relative to that standing record.
|
|
1636
1676
|
|
|
1637
1677
|
| Field | Stable meaning |
|
|
1638
1678
|
| --- | --- |
|
|
1639
|
-
| `unread_cells` | Distinct native cells in this frame's unread corridors; cross-axis intersections count once. This is an unread population, not a contrast count. |
|
|
1640
|
-
| `unread_corridors` | Nonempty array of ambiguous-endpoint runs, horizontal rows before vertical columns, each in native scan order. |
|
|
1679
|
+
| `unread_cells` | Distinct native cells in this frame's unread corridors (at setup, leaving out cells within T of the parts' recomposite); cross-axis intersections count once. This is an unread population, not a contrast count. |
|
|
1680
|
+
| `unread_corridors` | Nonempty array of ambiguous-endpoint runs (at setup, those with at least one cell where `dRecomposite > T`), horizontal rows before vertical columns, each in native scan order. |
|
|
1641
1681
|
| `unread_corridors[].axis` | `horizontal` or `vertical`. |
|
|
1642
1682
|
| `unread_corridors[].endpoints` | Two `[grid_x, grid_y, world_x, world_y, owner]` tuples in left/right or top/bottom order. Grid indices are zero-based, x right and y down; world coordinates are cell centres, y up. Owner codes are 0 for neither A/B reaching half alpha, 1 for A only, 2 for B only and 3 for both; no owner is inferred. |
|
|
1643
|
-
| `unread_corridors[].cells` | Interior world-centre `[x, y]` tuples in run order, excluding endpoints.
|
|
1644
|
-
| `unread_corridors[].cell_count` |
|
|
1683
|
+
| `unread_corridors[].cells` | Interior world-centre `[x, y]` tuples in run order, excluding endpoints. On a corridor whose endpoint owner is ambiguous (`0` or `3`) at setup, cells within T of the parts' recomposite (`dRecomposite <= T`) are left out of the unread population; the remaining interior cells (and on turn poses, all interior cells of the run) are reported without a rear-colour or endpoint-contrast filter; intersections may repeat across corridors. |
|
|
1684
|
+
| `unread_corridors[].cell_count` | The number of reported interior cells in that corridor (at setup, leaving out cells within T of the recomposite), exactly `cells.length`. |
|
|
1645
1685
|
| `unread_corridors[].row_scope` | `pair`. |
|
|
1646
1686
|
| `unread_corridors[].row_kind` | `evidence`. |
|
|
1647
1687
|
| `unread_corridors[].row_subjects` | The two selected part names in producer A/B order. |
|
|
@@ -1650,13 +1690,16 @@ Both fields are omitted when no ambiguous corridor is found, preserving the
|
|
|
1650
1690
|
bytes of fully read frames; no zero or empty-array placeholders are added.
|
|
1651
1691
|
`motion_opened` gains no field. Missing optional unread-corridor evidence does
|
|
1652
1692
|
not certify other unavailable readings or numeric colour underflow as read.
|
|
1653
|
-
A corridor with an ambiguous endpoint owner
|
|
1654
|
-
|
|
1655
|
-
|
|
1656
|
-
|
|
1657
|
-
evidence still makes the combined
|
|
1658
|
-
|
|
1659
|
-
|
|
1693
|
+
A corridor with an ambiguous endpoint owner (and, at setup, at least one cell
|
|
1694
|
+
with `dRecomposite > T`) remains unread without choosing an A/B owner. Readable
|
|
1695
|
+
corridors retain their measured cells: a standing count above allowance remains
|
|
1696
|
+
FAIL even with unread corridors, while unread corridors without a measured
|
|
1697
|
+
excess leave standing SKIP. Required unread evidence still makes the combined
|
|
1698
|
+
line FAIL. Idle `read_frames` counts idle frames where `motion_opened` is read
|
|
1699
|
+
(idle `standing` is never measured); on turn poses, `read_poses` excludes
|
|
1700
|
+
partially unread poses, including those whose measured count already fails,
|
|
1701
|
+
keeping them in `unmeasured_poses`. Setup is reported separately at
|
|
1702
|
+
`pairs[].setup`.
|
|
1660
1703
|
A boundary-colour PASS does not prove seam closure. Without `behind_seams`,
|
|
1661
1704
|
existing configurations remain optional and their checks retain their behavior;
|
|
1662
1705
|
no behind-part PASS is claimed. See [Behind-part seams](AUTHORING.md#behind-part-seams-issue-1314).
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@rig-c/parts",
|
|
3
|
-
"version": "2.
|
|
3
|
+
"version": "2.48.0",
|
|
4
4
|
"description": "AI-authored 2D character parts from one anime painting and its See-through layer decomposition: measured parts, weighted-mesh rig specs, verified through rig-c before anything is written. A CLI for agents that cannot see the image.",
|
|
5
5
|
"type": "module",
|
|
6
6
|
"exports": {
|
package/src/behindseams.ts
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
import { readFileSync } from 'node:fs';
|
|
2
2
|
import { createHash } from 'node:crypto';
|
|
3
3
|
import { isAbsolute, join, relative, resolve } from 'node:path';
|
|
4
|
-
import
|
|
4
|
+
import { Plate } from '@rig-c/core/plate';
|
|
5
5
|
import type { AttachmentRest, Frame } from '@rig-c/core/render-shared';
|
|
6
6
|
import { seamGridOf, seamsOf, setupCellReader, type SeamCell, type SeamGrid } from '@rig-c/core/seam';
|
|
7
7
|
import { DRAWN_ALPHA } from '@rig-c/core/passthrough';
|
|
@@ -14,6 +14,9 @@ export const BEHIND_SEAM_LINE = 'BEHIND_PART_SEAMS';
|
|
|
14
14
|
export const UNDECLARED_BEHIND_SEAM_REASON = 'HOLE: no requirements.behind_seams declares an authored threshold T; not measured, never a pass';
|
|
15
15
|
export const BEHIND_SEAM_CODE = 'CHECK_BEHIND_PART_SEAMS';
|
|
16
16
|
export const BEHIND_SEAM_UNMEASURED_CODE = 'CHECK_BEHIND_PART_SEAMS_UNMEASURED';
|
|
17
|
+
export const NO_PARTS_SETUP_STANDING_REASON = "no --parts manifest was supplied; setup standing compares the setup render with the parts' flat recomposite";
|
|
18
|
+
export const IDLE_STANDING_MOTION_READ_REASON = 'not applicable: motion_opened reads the pair';
|
|
19
|
+
export const IDLE_STANDING_NO_ORACLE_REASON = "idle standing is not measured: idle frames have no recomposite oracle, and the pair's idle reading is motion_opened";
|
|
17
20
|
|
|
18
21
|
export interface BehindSeams {
|
|
19
22
|
/** Opt in to the rig's declared ranges; never supplies or guesses a range. */
|
|
@@ -38,9 +41,15 @@ export interface BehindSeamsFramesInput {
|
|
|
38
41
|
pages: Map<string, Plate>;
|
|
39
42
|
stock: readonly BehindSeamsStockPair[] | null;
|
|
40
43
|
fps: number;
|
|
44
|
+
/** Setup recomposite frame rendered onto the pair's seam grid; absent or null when --parts was not supplied. */
|
|
45
|
+
recomposite?: Frame | null;
|
|
41
46
|
turn?: BehindSeamsTurnInput;
|
|
42
47
|
/** Issue #1403 plant only: the samples[] cap; production never sets it ({@link BEHIND_SAMPLE_CAP}). */
|
|
43
48
|
sampleCap?: number;
|
|
49
|
+
/** Issue #1408 plant only: skip the setup recomposite comparison; production never sets it. */
|
|
50
|
+
plantSkipRecomposite?: true;
|
|
51
|
+
/** Issue #1408 plant only: measure standing on idle frames without an oracle; production never sets it. */
|
|
52
|
+
plantMeasureIdleStanding?: true;
|
|
44
53
|
}
|
|
45
54
|
export interface BehindSeamsTurnPose {
|
|
46
55
|
name: string;
|
|
@@ -107,6 +116,8 @@ export interface BehindSeamsUnreadCorridor {
|
|
|
107
116
|
cell_count: number;
|
|
108
117
|
}
|
|
109
118
|
export interface BehindSeamsStanding extends BehindSeamsCount {
|
|
119
|
+
/** Present when standing is SKIP: at setup without --parts, or on every idle frame. */
|
|
120
|
+
reason?: string;
|
|
110
121
|
/** Distinct grid cells across all unread corridors, including cross-axis intersections. */
|
|
111
122
|
unread_cells?: number;
|
|
112
123
|
/** Omitted, together with unread_cells, when every corridor's endpoints are readable. */
|
|
@@ -135,6 +146,8 @@ export interface BehindSeamsHit {
|
|
|
135
146
|
}
|
|
136
147
|
export interface BehindSeamsReading {
|
|
137
148
|
status: 'PASS' | 'FAIL' | 'SKIP';
|
|
149
|
+
/** Present on the idle standing summary, which is never measured on idle frames. */
|
|
150
|
+
reason?: string;
|
|
138
151
|
frames: BehindSeamsHit[];
|
|
139
152
|
hit_frames: number;
|
|
140
153
|
max_px: number;
|
|
@@ -177,6 +190,8 @@ export interface BehindSeamsInput {
|
|
|
177
190
|
pairs: readonly MotionSeamPair[];
|
|
178
191
|
stockDir: string | null;
|
|
179
192
|
fps: number;
|
|
193
|
+
/** Flat recomposite of parts at their painted positions from --parts, or null/undefined when --parts was not supplied. */
|
|
194
|
+
recomposite?: { stage: { x: number; y: number; width: number; height: number }; raster: { width: number; height: number; data: ArrayLike<number> } } | null;
|
|
180
195
|
unsupported?: string;
|
|
181
196
|
turnBuild?: { build?: string; reason?: string };
|
|
182
197
|
}
|
|
@@ -315,15 +330,42 @@ function counted(count: BehindSeamsCount, cells: ReadonlySet<number>, grid: Seam
|
|
|
315
330
|
}
|
|
316
331
|
}
|
|
317
332
|
|
|
333
|
+
/** Issue #1405: the unread reason names each ambiguous owner case that occurs, with
|
|
334
|
+
* both members' composite alpha at one endpoint. The named point is the case's first
|
|
335
|
+
* endpoint in scan order, which is `unread_corridors` order: horizontal corridors top
|
|
336
|
+
* to bottom and left to right, then vertical corridors left to right and top to bottom,
|
|
337
|
+
* the left/top endpoint before the right/bottom one. Counts are distinct endpoint cells;
|
|
338
|
+
* a case with none is omitted. */
|
|
339
|
+
export function ambiguousOwnerReason(a: string, b: string, corridors: readonly BehindSeamsUnreadCorridor[], cells: number,
|
|
340
|
+
alpha: (gridX: number, gridY: number) => [number, number]): string {
|
|
341
|
+
const byte = (v: number): string => `${Math.round(v * 255 * 100) / 100}/255`;
|
|
342
|
+
const clauses: string[] = [];
|
|
343
|
+
for (const owner of [0, 3]) {
|
|
344
|
+
const seen = new Set<string>();
|
|
345
|
+
let first: BehindSeamsEndpoint | null = null;
|
|
346
|
+
for (const c of corridors) for (const e of c.endpoints) if (e[4] === owner) { seen.add(`${e[0]},${e[1]}`); first ??= e; }
|
|
347
|
+
if (first === null) continue;
|
|
348
|
+
const [ax, bx] = alpha(first[0], first[1]);
|
|
349
|
+
clauses.push(`${owner === 0 ? `neither "${a}" nor "${b}" reaches` : `both "${a}" and "${b}" reach`} 128/255 at ${seen.size} endpoint cell(s), first at world (${first[2]}, ${first[3]}) ("${a}" ${byte(ax)}, "${b}" ${byte(bx)})`);
|
|
350
|
+
}
|
|
351
|
+
return `standing endpoints include ambiguous half-alpha owners: ${corridors.length} unread corridor(s), ${cells} cell(s); ${clauses.join('; ')}; each endpoint requires exactly one member at 128/255 or more; unread corridors are not zero`;
|
|
352
|
+
}
|
|
353
|
+
|
|
318
354
|
interface Corridor { endpoints: Array<[number, number]> }
|
|
319
355
|
interface RasterCache { full: Plate; hidden: Plate }
|
|
320
356
|
|
|
357
|
+
function overWhite(data: Uint8Array, q: number, c: number): number {
|
|
358
|
+
return Math.round((data[q + c] * data[q + 3]) / 255 + 255 * (1 - data[q + 3] / 255));
|
|
359
|
+
}
|
|
360
|
+
|
|
321
361
|
function readBehindFrame(api: BehindSeamsApi, input: BehindSeamsFramesInput, pair: MotionSeamPair, frame: Frame, setup: boolean,
|
|
322
362
|
stock: BehindSeamsStockPair | undefined, threshold: number, allowance: number, unread: (frame: string, reason: string) => void,
|
|
323
363
|
cache: Map<Frame, Map<string, RasterCache>>, pose?: BehindSeamsTurnPose): BehindSeamsFrame {
|
|
364
|
+
const isIdle = !setup && pose === undefined;
|
|
324
365
|
const label = pose !== undefined ? `turn ${pose.name}` : setup ? 'setup' : `idle frame ${frame.index}`;
|
|
325
366
|
const family = pose !== undefined ? 'BEHIND_PART_SEAMS.turn.pairs[].frames' : setup ? 'BEHIND_PART_SEAMS.pairs[].setup' : 'BEHIND_PART_SEAMS.pairs[].frames';
|
|
326
|
-
const row: BehindSeamsFrame = { ...checkRow(family, 'pair', false, [pair.a, pair.b]), animation: pose !== undefined ? 'turn' : setup ? null : 'idle', index: frame.index, time: frame.time, ...(pose === undefined ? {} : { pose: pose.name, values: { ...pose.values }, ...(pose.observed_values === undefined ? {} : { observed_values: pose.observed_values, slider_times: pose.slider_times }) }), behind_slots: [], grid: null, motion_opened: emptyCount(),
|
|
367
|
+
const row: BehindSeamsFrame = { ...checkRow(family, 'pair', false, [pair.a, pair.b]), animation: pose !== undefined ? 'turn' : setup ? null : 'idle', index: frame.index, time: frame.time, ...(pose === undefined ? {} : { pose: pose.name, values: { ...pose.values }, ...(pose.observed_values === undefined ? {} : { observed_values: pose.observed_values, slider_times: pose.slider_times }) }), behind_slots: [], grid: null, motion_opened: emptyCount(),
|
|
368
|
+
standing: isIdle ? { ...emptyCount('SKIP'), reason: IDLE_STANDING_NO_ORACLE_REASON } : emptyCount() };
|
|
327
369
|
const fail = (reason: string): BehindSeamsFrame => { unread(label, reason); return row; };
|
|
328
370
|
if (pair.unread !== undefined) return fail(pair.unread);
|
|
329
371
|
if (frame.attachments === undefined) return fail('draw order/whole attachment geometry is unavailable');
|
|
@@ -343,55 +385,90 @@ function readBehindFrame(api: BehindSeamsApi, input: BehindSeamsFramesInput, pai
|
|
|
343
385
|
const { viewport, cell } = grid, { width, height } = viewport, n = width * height;
|
|
344
386
|
const A = material(n), B = material(n), project = api.projector(viewport);
|
|
345
387
|
try {
|
|
346
|
-
|
|
347
|
-
|
|
388
|
+
// Ordinary official full/hidden rendering, both transparent and on the SAME
|
|
389
|
+
// native seam grid. No --seam/--hide combination and no PNG nearest sampling.
|
|
390
|
+
let frameCache = cache.get(frame);
|
|
391
|
+
if (frameCache === undefined) { frameCache = new Map(); cache.set(frame, frameCache); }
|
|
392
|
+
const cacheKey = JSON.stringify([grid, row.behind_slots]);
|
|
393
|
+
let rasters = frameCache.get(cacheKey);
|
|
394
|
+
const behind = new Set(row.behind_slots);
|
|
395
|
+
if (rasters === undefined) {
|
|
396
|
+
rasters = { full: api.renderFrame(frame, input.pages, viewport, [0, 0, 0, 0]), hidden: api.renderFrame({ ...frame, pieces: frame.pieces.filter(p => !behind.has(p.slot)) }, input.pages, viewport, [0, 0, 0, 0]) };
|
|
397
|
+
frameCache.set(cacheKey, rasters);
|
|
398
|
+
}
|
|
399
|
+
const plantIdleStanding = isIdle && input.plantMeasureIdleStanding === true;
|
|
400
|
+
const measureStanding = pose !== undefined || plantIdleStanding || (setup && input.recomposite !== undefined && input.recomposite !== null);
|
|
401
|
+
let recompositeDiff: ((k: number) => number) | null = null;
|
|
402
|
+
if (setup) {
|
|
403
|
+
if (input.recomposite === undefined || input.recomposite === null) {
|
|
404
|
+
row.standing = { ...emptyCount('SKIP'), reason: NO_PARTS_SETUP_STANDING_REASON };
|
|
405
|
+
unread(label, NO_PARTS_SETUP_STANDING_REASON);
|
|
406
|
+
} else if (input.plantSkipRecomposite !== true) {
|
|
407
|
+
const recompositePlate = api.renderFrame(input.recomposite, input.pages, viewport, [0, 0, 0, 0]);
|
|
408
|
+
recompositeDiff = (k: number): number => {
|
|
409
|
+
const q = k * 4;
|
|
410
|
+
if (recompositePlate.data[q + 3] === 0) return Infinity;
|
|
411
|
+
return Math.max(
|
|
412
|
+
Math.abs(overWhite(rasters!.full.data, q, 0) - overWhite(recompositePlate.data, q, 0)),
|
|
413
|
+
Math.abs(overWhite(rasters!.full.data, q, 1) - overWhite(recompositePlate.data, q, 1)),
|
|
414
|
+
Math.abs(overWhite(rasters!.full.data, q, 2) - overWhite(recompositePlate.data, q, 2)),
|
|
415
|
+
);
|
|
416
|
+
};
|
|
417
|
+
}
|
|
348
418
|
}
|
|
349
|
-
const half = DRAWN_ALPHA / 255;
|
|
350
|
-
const low = (k: number): boolean => A.alpha[k] + B.alpha[k] * (1 - A.alpha[k]) < half;
|
|
351
|
-
const owner = (k: number): number => A.alpha[k] >= half ? B.alpha[k] >= half ? 3 : 1 : B.alpha[k] >= half ? 2 : 0;
|
|
352
419
|
const corridors = new Map<number, Corridor>();
|
|
353
420
|
const support = new Set<number>();
|
|
354
421
|
const unreadCells = new Set<number>(), unreadCorridors: BehindSeamsUnreadCorridor[] = [];
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
360
|
-
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
while (j < length
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
370
|
-
|
|
371
|
-
|
|
372
|
-
const
|
|
422
|
+
const half = DRAWN_ALPHA / 255;
|
|
423
|
+
const low = (k: number): boolean => A.alpha[k] + B.alpha[k] * (1 - A.alpha[k]) < half;
|
|
424
|
+
const owner = (k: number): number => A.alpha[k] >= half ? B.alpha[k] >= half ? 3 : 1 : B.alpha[k] >= half ? 2 : 0;
|
|
425
|
+
if (measureStanding) {
|
|
426
|
+
for (const piece of frame.pieces) if (piece.slot === pair.a || piece.slot === pair.b) {
|
|
427
|
+
api.rasterisePiece(api.pageFor(input.pages, piece), piece, project, viewport, (x, y, r, g, b, alpha) => add(piece.slot === pair.a ? A : B, y * width + x, [r, g, b], alpha / 255));
|
|
428
|
+
}
|
|
429
|
+
// A measured overlap is support even when the opening population is empty.
|
|
430
|
+
for (let k = 0; k < n; k++) if (owner(k) === 3) support.add(k);
|
|
431
|
+
for (const [length, lines, step, start] of [[width, height, 1, width], [height, width, width, 1]]) for (let l = 0; l < lines; l++) {
|
|
432
|
+
let j = 0;
|
|
433
|
+
while (j < length) {
|
|
434
|
+
const k = l * start + j * step;
|
|
435
|
+
if (!low(k)) {
|
|
436
|
+
if (j > 0) { const prev = k - step; if (!low(prev) && owner(prev) > 0 && owner(prev) < 3 && owner(k) > 0 && owner(k) < 3 && owner(prev) !== owner(k)) { support.add(prev); support.add(k); } }
|
|
437
|
+
j++; continue;
|
|
438
|
+
}
|
|
439
|
+
const first = j;
|
|
440
|
+
while (j < length && low(l * start + j * step)) j++;
|
|
441
|
+
if (first === 0 || j === length) continue; // outer silhouette, never a bracketed opening
|
|
442
|
+
const left = l * start + (first - 1) * step, right = l * start + j * step;
|
|
443
|
+
const a = owner(left), b = owner(right);
|
|
444
|
+
if (a === 0 || b === 0 || a === 3 || b === 3) {
|
|
445
|
+
const endpoint = (at: number, owner: number): BehindSeamsEndpoint => [at % width, Math.floor(at / width), ...centre(grid, at), owner];
|
|
446
|
+
const cells: Array<[number, number]> = [];
|
|
447
|
+
for (let t = first; t < j; t++) {
|
|
448
|
+
const at = l * start + t * step;
|
|
449
|
+
if (recompositeDiff !== null && recompositeDiff(at) <= threshold) continue;
|
|
450
|
+
unreadCells.add(at); cells.push(centre(grid, at));
|
|
451
|
+
}
|
|
452
|
+
if (cells.length === 0) continue;
|
|
453
|
+
unreadCorridors.push({ ...checkRow('BEHIND_PART_SEAMS.unread_corridors', 'pair', false, [pair.a, pair.b]),
|
|
454
|
+
axis: step === 1 ? 'horizontal' : 'vertical', endpoints: [endpoint(left, a), endpoint(right, b)], cells, cell_count: cells.length });
|
|
455
|
+
continue;
|
|
456
|
+
}
|
|
457
|
+
if (a === b) continue;
|
|
458
|
+
support.add(left); support.add(right);
|
|
459
|
+
const endpoints: [number, number] = a === 1 ? [left, right] : [right, left];
|
|
373
460
|
for (let t = first; t < j; t++) {
|
|
374
461
|
const at = l * start + t * step;
|
|
375
|
-
|
|
462
|
+
const c = corridors.get(at) ?? { endpoints: [] };
|
|
463
|
+
c.endpoints.push(endpoints); corridors.set(at, c);
|
|
376
464
|
}
|
|
377
|
-
unreadCorridors.push({ ...checkRow('BEHIND_PART_SEAMS.unread_corridors', 'pair', false, [pair.a, pair.b]),
|
|
378
|
-
axis: step === 1 ? 'horizontal' : 'vertical', endpoints: [endpoint(left, a), endpoint(right, b)], cells, cell_count: cells.length });
|
|
379
|
-
continue;
|
|
380
|
-
}
|
|
381
|
-
if (a === b) continue;
|
|
382
|
-
support.add(left); support.add(right);
|
|
383
|
-
const endpoints: [number, number] = a === 1 ? [left, right] : [right, left];
|
|
384
|
-
for (let t = first; t < j; t++) {
|
|
385
|
-
const at = l * start + t * step;
|
|
386
|
-
const c = corridors.get(at) ?? { endpoints: [] };
|
|
387
|
-
c.endpoints.push(endpoints); corridors.set(at, c);
|
|
388
465
|
}
|
|
389
466
|
}
|
|
390
|
-
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
467
|
+
row.standing.boundary_cells = support.size;
|
|
468
|
+
if (unreadCorridors.length > 0) {
|
|
469
|
+
row.standing.unread_cells = unreadCells.size;
|
|
470
|
+
row.standing.unread_corridors = unreadCorridors;
|
|
471
|
+
}
|
|
395
472
|
}
|
|
396
473
|
let motionReadable = setup;
|
|
397
474
|
const motionCells = new Map<number, SeamCell>();
|
|
@@ -414,17 +491,6 @@ function readBehindFrame(api: BehindSeamsApi, input: BehindSeamsFramesInput, pai
|
|
|
414
491
|
}
|
|
415
492
|
}
|
|
416
493
|
}
|
|
417
|
-
// Ordinary official full/hidden rendering, both transparent and on the SAME
|
|
418
|
-
// native seam grid. No --seam/--hide combination and no PNG nearest sampling.
|
|
419
|
-
let frameCache = cache.get(frame);
|
|
420
|
-
if (frameCache === undefined) { frameCache = new Map(); cache.set(frame, frameCache); }
|
|
421
|
-
const cacheKey = JSON.stringify([grid, row.behind_slots]);
|
|
422
|
-
let rasters = frameCache.get(cacheKey);
|
|
423
|
-
const behind = new Set(row.behind_slots);
|
|
424
|
-
if (rasters === undefined) {
|
|
425
|
-
rasters = { full: api.renderFrame(frame, input.pages, viewport, [0, 0, 0, 0]), hidden: api.renderFrame({ ...frame, pieces: frame.pieces.filter(p => !behind.has(p.slot)) }, input.pages, viewport, [0, 0, 0, 0]) };
|
|
426
|
-
frameCache.set(cacheKey, rasters);
|
|
427
|
-
}
|
|
428
494
|
const targets = new Set([...corridors.keys(), ...motionCells.keys()]);
|
|
429
495
|
const rear = material(n), weights = new Map<number, Map<string, number>>();
|
|
430
496
|
const surviving = new Set<number>(), underflow = new Set<number>();
|
|
@@ -454,31 +520,35 @@ function readBehindFrame(api: BehindSeamsApi, input: BehindSeamsFramesInput, pai
|
|
|
454
520
|
contributors: row.behind_slots.filter(slot => (weights.get(k)?.get(slot) ?? 0) > 0).map(slot => ({ ...checkRow('BEHIND_PART_SEAMS.contributors', 'pair', false, [pair.a, pair.b]), slot, weight: weights.get(k)!.get(slot)! })), distances, counted: counts };
|
|
455
521
|
};
|
|
456
522
|
const standingHits = new Set<number>(), motionHits = new Set<number>();
|
|
457
|
-
|
|
458
|
-
|
|
459
|
-
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
|
|
463
|
-
|
|
464
|
-
|
|
465
|
-
const
|
|
466
|
-
|
|
467
|
-
|
|
468
|
-
|
|
523
|
+
const cap = input.sampleCap ?? BEHIND_SAMPLE_CAP;
|
|
524
|
+
if (measureStanding) {
|
|
525
|
+
let standingUnderflow = false;
|
|
526
|
+
const worstStanding = new WorstStanding(cap);
|
|
527
|
+
for (const [k, corridor] of corridors) {
|
|
528
|
+
if (!surviving.has(k)) continue;
|
|
529
|
+
if (rear.alpha[k] <= 0 || underflow.has(k)) { unread(label, 'positive symbolic rear contribution underflowed its numeric colour weight'); standingUnderflow = true; continue; }
|
|
530
|
+
row.standing.geometric_px++;
|
|
531
|
+
const dr = recompositeDiff === null ? Infinity : recompositeDiff(k);
|
|
532
|
+
let chosen: [number, number] | null = null, raw = false, qualifies = false;
|
|
533
|
+
for (const [a, b] of corridor.endpoints) {
|
|
534
|
+
const d: [number, number] = [distance(rear, k, colour(A, a)), distance(rear, k, colour(B, b))];
|
|
535
|
+
const r = d[0] > 0 && d[1] > 0 && dr > 0, q = d[0] > threshold && d[1] > threshold && dr > threshold;
|
|
536
|
+
if (chosen === null || q && !qualifies || r && !raw) chosen = d;
|
|
537
|
+
raw ||= r; qualifies ||= q;
|
|
538
|
+
}
|
|
539
|
+
if (raw) row.standing.raw_px++;
|
|
540
|
+
if (qualifies) standingHits.add(k);
|
|
541
|
+
worstStanding.offer(k, chosen as [number, number], qualifies);
|
|
542
|
+
}
|
|
543
|
+
row.standing.samples = worstStanding.inOrder().map(c => sample(c.k, c.d, c.q));
|
|
544
|
+
if (worstStanding.seen > cap) row.standing.samples_omitted = worstStanding.seen - cap;
|
|
545
|
+
counted(row.standing, standingHits, grid, allowance);
|
|
546
|
+
// Incomplete coverage cannot certify PASS, but cannot hide a measured failure.
|
|
547
|
+
if (support.size === 0 || unreadCorridors.length > 0 || standingUnderflow) {
|
|
548
|
+
if (row.standing.status !== 'FAIL') row.standing.status = 'SKIP';
|
|
549
|
+
if (unreadCorridors.length > 0) unread(label, ambiguousOwnerReason(pair.a, pair.b, unreadCorridors, unreadCells.size, (x, y) => [A.alpha[y * width + x], B.alpha[y * width + x]]));
|
|
550
|
+
else if (support.size === 0) unread(label, 'no A/B boundary support was measured (no overlap, contact or bracketed corridor)');
|
|
469
551
|
}
|
|
470
|
-
if (raw) row.standing.raw_px++;
|
|
471
|
-
if (qualifies) standingHits.add(k);
|
|
472
|
-
worstStanding.offer(k, chosen as [number, number], qualifies);
|
|
473
|
-
}
|
|
474
|
-
row.standing.samples = worstStanding.inOrder().map(c => sample(c.k, c.d, c.q));
|
|
475
|
-
if (worstStanding.seen > cap) row.standing.samples_omitted = worstStanding.seen - cap;
|
|
476
|
-
counted(row.standing, standingHits, grid, allowance);
|
|
477
|
-
// Incomplete coverage cannot certify PASS, but cannot hide a measured failure.
|
|
478
|
-
if (support.size === 0 || unreadCorridors.length > 0 || standingUnderflow) {
|
|
479
|
-
if (row.standing.status !== 'FAIL') row.standing.status = 'SKIP';
|
|
480
|
-
if (unreadCorridors.length > 0) unread(label, 'standing endpoints include ambiguous half-alpha owners; unread corridors are not zero');
|
|
481
|
-
else if (support.size === 0) unread(label, 'no A/B boundary support was measured (no overlap, contact or bracketed corridor)');
|
|
482
552
|
}
|
|
483
553
|
for (const k of motionCells.keys()) {
|
|
484
554
|
if (rasters.hidden.data[k * 4 + 3] !== 0 || rasters.full.data[k * 4 + 3] === 0 || !surviving.has(k)) continue;
|
|
@@ -506,6 +576,12 @@ function readBehindFrame(api: BehindSeamsApi, input: BehindSeamsFramesInput, pai
|
|
|
506
576
|
row.motion_opened.geometric_px = motionHits.size; row.motion_opened.raw_px = motionHits.size;
|
|
507
577
|
counted(row.motion_opened, motionHits, grid, allowance);
|
|
508
578
|
if (!motionReadable) row.motion_opened.status = 'SKIP';
|
|
579
|
+
if (isIdle && !plantIdleStanding) {
|
|
580
|
+
row.standing = {
|
|
581
|
+
...emptyCount('SKIP'),
|
|
582
|
+
reason: row.motion_opened.status !== 'SKIP' ? IDLE_STANDING_MOTION_READ_REASON : IDLE_STANDING_NO_ORACLE_REASON,
|
|
583
|
+
};
|
|
584
|
+
}
|
|
509
585
|
return { ...row, ...checkRow(family, 'pair', row.standing.status === 'FAIL' || row.motion_opened.status === 'FAIL', [pair.a, pair.b]) };
|
|
510
586
|
} catch (e) { return fail(`official raster/source reading unavailable: ${e instanceof Error ? e.message : String(e)}`); }
|
|
511
587
|
}
|
|
@@ -549,6 +625,8 @@ export function measureBehindSeamFrames(api: BehindSeamsApi, input: BehindSeamsF
|
|
|
549
625
|
problems.push(...shape);
|
|
550
626
|
if (shape.length > 0) { line.status = 'FAIL'; return line; }
|
|
551
627
|
for (const p of declared.pairs ?? []) if (!selected.has(keyOf(p.part, p.neighbour))) unread(null, 'declaration', `override pair "${p.part}|${p.neighbour}" is not in motionSeamSelection; an override does not create an adjacent pair`, true);
|
|
628
|
+
const active = declared.threshold !== undefined || declared.pairs?.some(p => p.threshold !== undefined) === true;
|
|
629
|
+
if (input.pairs.length === 0 && (input.recomposite === undefined || input.recomposite === null)) unread(null, 'setup', NO_PARTS_SETUP_STANDING_REASON, active);
|
|
552
630
|
if (input.pairs.length === 0) unread(null, 'selection', 'no selected motion seam pair; no boundary population was measured', declared.threshold !== undefined);
|
|
553
631
|
const rows = input.pairs.map(pair => {
|
|
554
632
|
const override = declared.pairs?.find(p => keyOf(p.part, p.neighbour) === keyOf(pair.a, pair.b));
|
|
@@ -582,23 +660,29 @@ export function measureBehindSeamFrames(api: BehindSeamsApi, input: BehindSeamsF
|
|
|
582
660
|
for (const r of rows) {
|
|
583
661
|
const { pair, threshold, allowance, setup, frames } = r;
|
|
584
662
|
const parts: [string, string] = [pair.a, pair.b];
|
|
585
|
-
const motion = reading(frames, 'motion_opened', input.fps, allowance, parts)
|
|
663
|
+
const motion = reading(frames, 'motion_opened', input.fps, allowance, parts);
|
|
586
664
|
if ((setup === null || setup.motion_opened.status === 'SKIP') && motion.status !== 'FAIL') motion.status = 'SKIP';
|
|
587
|
-
|
|
588
|
-
|
|
589
|
-
|
|
590
|
-
|
|
591
|
-
|
|
592
|
-
|
|
593
|
-
}
|
|
665
|
+
const idleStandingReason = motion.status !== 'SKIP' ? IDLE_STANDING_MOTION_READ_REASON : IDLE_STANDING_NO_ORACLE_REASON;
|
|
666
|
+
const rawStanding = reading(frames, 'standing', input.fps, allowance, parts);
|
|
667
|
+
const standing: BehindSeamsReading = input.plantMeasureIdleStanding === true
|
|
668
|
+
? rawStanding
|
|
669
|
+
: { ...rawStanding, status: 'SKIP', reason: idleStandingReason };
|
|
670
|
+
if (motion.max_px > allowance) {
|
|
671
|
+
problems.push({ code: BEHIND_SEAM_CODE, object: `pair "${pair.pair}" motion_opened`, detail: `idle frame ${motion.worst?.index} (${motion.max_px} cells) exceeds allowance ${allowance}; authored threshold ${threshold}, native seam cells, no one-cell floor or rest mask` });
|
|
672
|
+
}
|
|
673
|
+
if ((setup?.standing.px ?? 0) > allowance) {
|
|
674
|
+
problems.push({ code: BEHIND_SEAM_CODE, object: `pair "${pair.pair}" setup standing`, detail: `setup (${setup!.standing.px} cells) exceeds allowance ${allowance}; authored threshold ${threshold}, native seam cells, no one-cell floor or rest mask` });
|
|
675
|
+
}
|
|
676
|
+
if (input.plantMeasureIdleStanding === true && standing.max_px > allowance) {
|
|
677
|
+
problems.push({ code: BEHIND_SEAM_CODE, object: `pair "${pair.pair}" standing`, detail: `idle frame ${standing.worst?.index} (${standing.max_px} cells) exceeds allowance ${allowance}; authored threshold ${threshold}, native seam cells, no one-cell floor or rest mask` });
|
|
594
678
|
}
|
|
595
|
-
const failed = motion.status === 'FAIL' || standing.status === 'FAIL' || line.unmeasured.some(u => u.pair === pair.pair && threshold !== null);
|
|
596
|
-
const readFrames = frames.filter(f => f.motion_opened.status !== 'SKIP' &&
|
|
597
|
-
|
|
679
|
+
const failed = motion.status === 'FAIL' || setup?.standing.status === 'FAIL' || standing.status === 'FAIL' || line.unmeasured.some(u => u.pair === pair.pair && threshold !== null);
|
|
680
|
+
const readFrames = frames.filter(f => f.motion_opened.status !== 'SKIP' &&
|
|
681
|
+
!line.unmeasured.some(u => u.pair === pair.pair && u.frame === `idle frame ${f.index}`)).length;
|
|
598
682
|
line.pairs.push({ ...checkRow('BEHIND_PART_SEAMS.pairs', 'pair', failed, parts), animation: 'idle', pair: pair.pair, parts, declared: [...pair.declared], threshold, allowance, setup, frames, motion_opened: motion, standing,
|
|
599
683
|
sampled_frames: input.idle.length, read_frames: readFrames, unmeasured_frames: input.idle.length - readFrames });
|
|
600
684
|
}
|
|
601
|
-
line.status = problems.length > start ? 'FAIL' : line.pairs.length === 0 || line.pairs.some(p => p.threshold === null || p.
|
|
685
|
+
line.status = problems.length > start ? 'FAIL' : line.pairs.length === 0 || line.pairs.some(p => p.threshold === null || p.setup === null || p.setup.standing.status === 'SKIP' || p.motion_opened.status === 'SKIP') ? 'SKIP' : 'PASS';
|
|
602
686
|
if (declared.turn === true) {
|
|
603
687
|
line.turn = measureBehindTurnFrames(api, input, declared, problems);
|
|
604
688
|
if (line.turn.status === 'FAIL' || problems.length > start) line.status = 'FAIL';
|
|
@@ -896,7 +980,23 @@ export function measureBehindSeams(api: typeof import('@rig-c/core/render-shared
|
|
|
896
980
|
if (input.stockDir === null || sampled.setup === null) throw new Error('existing full stock seam render/setup is unavailable');
|
|
897
981
|
stock = stockOf(input.stockDir, input.pairs.filter(p => p.unread === undefined), input.fps, sampled.setup, sampled.idle, sampled.rest);
|
|
898
982
|
} catch (e) { stockError = e instanceof Error ? e.message : String(e); }
|
|
899
|
-
const
|
|
983
|
+
const pages = new Map(candidate.pages);
|
|
984
|
+
let recomposite: Frame | null = null;
|
|
985
|
+
if (input.recomposite !== undefined && input.recomposite !== null) {
|
|
986
|
+
const { stage, raster } = input.recomposite;
|
|
987
|
+
if (raster.width !== stage.width || raster.height !== stage.height) {
|
|
988
|
+
return fail(`parts.json rig_size (${raster.width}x${raster.height}) differs from rig stage (${stage.width}x${stage.height}); setup standing does not resample the parts' recomposite`);
|
|
989
|
+
}
|
|
990
|
+
const page = new Plate(raster.width, raster.height);
|
|
991
|
+
page.data.set(raster.data);
|
|
992
|
+
const pageName = 'behind-seams:recomposite';
|
|
993
|
+
pages.set(pageName, page);
|
|
994
|
+
const wx0 = stage.x, wx1 = stage.x + stage.width, wy0 = stage.y, wy1 = stage.y + stage.height;
|
|
995
|
+
recomposite = { index: 0, time: 0, pieces: [{ kind: 'region', slot: 'recomposite', page: pageName, tint: [1, 1, 1, 1],
|
|
996
|
+
world: [wx1, wy1, wx0, wy1, wx0, wy0, wx1, wy0], uvs: [1, 0, 0, 0, 0, 1, 1, 1] }] };
|
|
997
|
+
}
|
|
998
|
+
const line = measureBehindSeamFrames(api, { ...sampled, pairs: input.pairs, pages, stock, fps: input.fps,
|
|
999
|
+
recomposite,
|
|
900
1000
|
...(declared.turn === true ? { turn: sampleBehindTurn(api, input, candidate, sampled.setup, acceptedPoser) } : {}) }, declared, problems);
|
|
901
1001
|
if (stockError !== null) {
|
|
902
1002
|
line.status = 'FAIL';
|
|
@@ -915,9 +1015,12 @@ export function behindSeamLines(line: BehindSeamsMeasured | null): string[] {
|
|
|
915
1015
|
const setup = p.setup;
|
|
916
1016
|
const summary = (kind: 'motion_opened' | 'standing'): string => {
|
|
917
1017
|
const r = p[kind], w = r.worst;
|
|
1018
|
+
if (r.reason !== undefined) {
|
|
1019
|
+
return `${BEHIND_SEAM_LINE}: pair "${p.pair}" ${kind} ${r.status} — ${r.reason}; threshold ${p.threshold === null ? 'undeclared' : p.threshold}, allowance ${p.allowance}`;
|
|
1020
|
+
}
|
|
918
1021
|
return `${BEHIND_SEAM_LINE}: pair "${p.pair}" ${kind} ${r.status} — ${r.hit_frames}/${p.frames.length} idle hit frames, sampled/read/unmeasured ${p.sampled_frames ?? p.frames.length}/${p.read_frames ?? 0}/${p.unmeasured_frames ?? 0}, max_px ${r.max_px}, max_run ${r.max_run.frames} frames (${r.max_run.seconds} s), max_spatial_run_cells ${r.max_spatial_run_cells} (${r.max_spatial_run_world} world units), earliest worst ${w === null ? 'none' : `frame ${w.index} t ${w.time}, cell ${w.cell}, box [${w.box.join(', ')}]`}; threshold ${p.threshold === null ? 'undeclared' : p.threshold}, allowance ${p.allowance}`;
|
|
919
1022
|
};
|
|
920
|
-
const setupStanding = setup === null ? '' : setup.standing.px > 0 && setup.standing.status === 'SKIP' ? `${setup.standing.px} cells` : `${setup.standing.status}, ${setup.standing.px} cells`;
|
|
1023
|
+
const setupStanding = setup === null ? '' : setup.standing.reason !== undefined ? `${setup.standing.status} (${setup.standing.reason}), ${setup.standing.px} cells` : setup.standing.px > 0 && setup.standing.status === 'SKIP' ? `${setup.standing.px} cells` : `${setup.standing.status}, ${setup.standing.px} cells`;
|
|
921
1024
|
return [summary('motion_opened'), summary('standing'), `${BEHIND_SEAM_LINE}: pair "${p.pair}" setup ${setup === null ? 'SKIP — HOLE: setup not read' : `standing ${setupStanding}; motion_opened ${setup.motion_opened.status}, ${setup.motion_opened.px} cells; behind [${setup.behind_slots.join(', ')}]`}`];
|
|
922
1025
|
}),
|
|
923
1026
|
...(line.turn === undefined ? [] : [
|
package/src/check.ts
CHANGED
|
@@ -7676,8 +7676,10 @@ export function runCheck(rigDir: string, outDir: string, rigc: RigcRunner, parts
|
|
|
7676
7676
|
}
|
|
7677
7677
|
}
|
|
7678
7678
|
}
|
|
7679
|
+
const behindSlotOrder = (Array.isArray(inp.rig.slots) ? inp.rig.slots : []).filter(isRecord).map((sl) => String(sl.name));
|
|
7679
7680
|
behindSeams = measureBehindSeams(officialRenderer(), {
|
|
7680
7681
|
build: buildDir, rig: inp.rig, pairs: behindPairs, stockDir: behindStockDir, fps: IDLE_FPS,
|
|
7682
|
+
recomposite: inp.parts === null ? null : { stage: inp.stage, raster: flatComposite(inp.parts, inp.partsDir, [255, 255, 255, 255], behindSlotOrder) },
|
|
7681
7683
|
...(turnBuild === undefined ? {} : { turnBuild }),
|
|
7682
7684
|
...(behindUnsupported.length === 0 ? {} : { unsupported: behindUnsupported.join('; ') }),
|
|
7683
7685
|
}, behindDeclared, problems);
|