@trillboards/edge-sdk 0.2.74 → 0.2.78

package/dist/zoneContainment.d.ts

@@ -0,0 +1,148 @@
+/**
+ * zoneContainment — "is this thing in the area the operator drew?", in code.
+ *
+ * ── WHY THIS EXISTS ────────────────────────────────────────────────────────
+ *
+ * The operator drags a rectangle on their camera and expects "only tell me about
+ * THIS". Today that promise is kept by writing the rectangle's coordinates into
+ * an English sentence and asking a vision-language model to respect it. Measured
+ * on production, before and after the description was repaired:
+ *
+ *   - the focused field agreed with the UNRESTRICTED field on 99.5% of frames
+ *   - after the fix the model demonstrably READS the constraint (divergence
+ *     0.34% -> 3.58%), and yet `focus_true` is still 0 of 391 in a window with
+ *     MORE person activity than the one before it
+ *
+ * So the repaired prose suppresses, and whether it suppresses the RIGHT things
+ * is not knowable from the model's answer alone. A rectangle is geometry. Asking
+ * a language model to do geometry, and then having no way to check its working,
+ * is the part that has to stop.
+ *
+ * ── THE ANCHOR IS THE WHOLE PROBLEM, AND IT IS NOT A THRESHOLD ─────────────
+ *
+ * A person is a tall box. Someone standing on the pavement BESIDE a driveway
+ * overlaps the driveway's rectangle in image space with their head and shoulders
+ * while their feet are firmly outside it. Area-overlap answers "yes" and is
+ * wrong; whole-box containment answers "no" for anyone standing at the edge and
+ * is also wrong. Neither is rescued by tuning a fraction, because the error is
+ * not one of degree — the box's top is not where the person IS.
+ *
+ * A camera looks down. The ground plane is where a person occupies space, and
+ * the bottom edge of their box is where they touch it. So `groundContact` — the
+ * bottom-centre point — is the default, and it needs NO threshold: a point is
+ * inside a rectangle or it is not. That is the whole reason to prefer it. A
+ * magic fraction nobody can justify is exactly what this codebase asks not to
+ * invent, and here the physics removes the need for one.
+ *
+ * `areaOverlap` is offered for the cases where the ground plane is not the
+ * subject — a package on a shelf, a vehicle in a wide overhead view — and there
+ * the fraction is a REQUIRED, caller-supplied argument, never a default, so it
+ * appears in the route's own configuration where an operator's expectation can
+ * be compared against it.
+ *
+ * ── COORDINATE SPACES: EXACTLY ONE CONVERSION, HERE ────────────────────────
+ *
+ * Detector boxes are PIXELS in the submitted frame. `sensing_route_screens`
+ * stores `focus_x/y/width/height` NORMALIZED to [0,1] — that is what the portal
+ * writes and what `focusRegionFromScreenRow` reads. The two meet in exactly one
+ * place: this file. Every function takes the frame's dimensions explicitly
+ * rather than carrying a resolution around, because a stale resolution is
+ * silent and a missing argument is not.
+ *
+ * @reuse-audit
+ *   considered: FaceDetector.iou (edge-sensing/src/processors/FaceDetector.ts)
+ *     - not reused: IoU is a SYMMETRIC similarity between two detections, used
+ *       for NMS and tracking. Containment is asymmetric — "how much of the BOX
+ *       is in the RECT" — and IoU's denominator includes the rectangle's own
+ *       area, so a small person inside a large zone scores near zero on IoU and
+ *       1.0 here. Same rectangles, different question. When the detector's own
+ *       NMS lands it must call FaceDetector's iou, not a copy.
+ *   considered: camera-alert-focus-selector.tsx (portal)
+ *     - not reused: drag/clamp only, no containment predicate, and it is React
+ *       in a different package. Its clamping is the reason `assertNormalizedRect`
+ *       can be strict — the rect always arrives already inside [0,1].
+ */
+/** A rectangle in normalized [0,1] frame coordinates, as the operator drew it. */
+export interface NormalizedRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/** A box in PIXELS of the frame it was detected in. */
+export interface PixelBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface FrameSize {
+    width: number;
+    height: number;
+}
+/**
+ * How to decide whether a box is "in" the zone.
+ *
+ * `groundContact` — the box's bottom-centre point falls inside the rect. The
+ * default, and the only one with a physical argument behind it.
+ *
+ * `areaOverlap` — at least `minOverlap` of the box's own area falls inside the
+ * rect. `minOverlap` is REQUIRED; there is no defensible default and inventing
+ * one would bury the decision.
+ */
+export type ZonePredicate = {
+    kind: 'groundContact';
+} | {
+    kind: 'areaOverlap';
+    minOverlap: number;
+};
+export declare const DEFAULT_ZONE_PREDICATE: ZonePredicate;
+export interface ZoneVerdict {
+    inside: boolean;
+    /**
+     * Fraction of the box's area inside the rect, ALWAYS computed regardless of
+     * predicate.
+     *
+     * Reported even when unused because the alternative — logging only the boolean
+     * — makes a disputed verdict unreviewable after the fact. An operator saying
+     * "it missed someone standing right there" is answerable with 0.62 and
+     * unanswerable with `false`.
+     */
+    overlapFraction: number;
+    /** The bottom-centre point in normalized coordinates, for the same reason. */
+    groundContact: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * A rect outside [0,1] is a COORDINATE-SPACE error, and it must throw.
+ *
+ * The one way this happens is a caller passing pixels where normalized values
+ * belong — and pixels are numerically valid, so the verdict would just be
+ * silently wrong forever: a rect at x=640 clamps to the frame's right edge and
+ * every person reads as outside it. That failure has no symptom other than an
+ * alert that never fires, which is the failure this whole area keeps producing.
+ * Refusing loudly is the only version anybody notices.
+ */
+export declare function assertNormalizedRect(rect: NormalizedRect): void;
+/** Convert a pixel box to normalized coordinates. The only conversion there is. */
+export declare function normalizeBox(box: PixelBox, frame: FrameSize): NormalizedRect;
+/**
+ * Is this detection inside the operator's rectangle?
+ *
+ * Throws on a malformed rect or frame — see `assertNormalizedRect`. Never
+ * returns a verdict it could not compute.
+ */
+export declare function evaluateZone(box: PixelBox, frame: FrameSize, rect: NormalizedRect, predicate?: ZonePredicate): ZoneVerdict;
+/**
+ * Count the detections inside the zone.
+ *
+ * This is the integer the focused field has been asking a language model for.
+ * `null` rect means NO zone was drawn, and then the count is every detection —
+ * which is what the unfocused field already means, so absence degrades to the
+ * existing behaviour rather than to zero. A zone that silently counts nothing is
+ * indistinguishable from a quiet venue, and that is the whole failure mode here.
+ */
+export declare function countInZone(boxes: PixelBox[], frame: FrameSize, rect: NormalizedRect | null | undefined, predicate?: ZonePredicate): number;
+//# sourceMappingURL=zoneContainment.d.ts.map

package/dist/zoneContainment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zoneContainment.d.ts","sourceRoot":"","sources":["../src/zoneContainment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAEH,kFAAkF;AAClF,MAAM,WAAW,cAAc;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,uDAAuD;AACvD,MAAM,WAAW,QAAQ;IACvB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GACzB;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC;AAEhD,eAAO,MAAM,sBAAsB,EAAE,aAAyC,CAAC;AAE/E,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,OAAO,CAAC;IAChB;;;;;;;;OAQG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB,8EAA8E;IAC9E,aAAa,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;CACzC;AAQD;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,cAAc,GAAG,IAAI,CAgB/D;AAED,mFAAmF;AACnF,wBAAgB,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,GAAG,cAAc,CAgB5E;AAiBD;;;;;GAKG;AACH,wBAAgB,YAAY,CAC1B,GAAG,EAAE,QAAQ,EACb,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,cAAc,EACpB,SAAS,GAAE,aAAsC,GAChD,WAAW,CAmBb;AAED;;;;;;;;GAQG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,QAAQ,EAAE,EACjB,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,cAAc,GAAG,IAAI,GAAG,SAAS,EACvC,SAAS,GAAE,aAAsC,GAChD,MAAM,CAGR"}

package/dist/zoneContainment.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * zoneContainment — "is this thing in the area the operator drew?", in code.
+ *
+ * ── WHY THIS EXISTS ────────────────────────────────────────────────────────
+ *
+ * The operator drags a rectangle on their camera and expects "only tell me about
+ * THIS". Today that promise is kept by writing the rectangle's coordinates into
+ * an English sentence and asking a vision-language model to respect it. Measured
+ * on production, before and after the description was repaired:
+ *
+ *   - the focused field agreed with the UNRESTRICTED field on 99.5% of frames
+ *   - after the fix the model demonstrably READS the constraint (divergence
+ *     0.34% -> 3.58%), and yet `focus_true` is still 0 of 391 in a window with
+ *     MORE person activity than the one before it
+ *
+ * So the repaired prose suppresses, and whether it suppresses the RIGHT things
+ * is not knowable from the model's answer alone. A rectangle is geometry. Asking
+ * a language model to do geometry, and then having no way to check its working,
+ * is the part that has to stop.
+ *
+ * ── THE ANCHOR IS THE WHOLE PROBLEM, AND IT IS NOT A THRESHOLD ─────────────
+ *
+ * A person is a tall box. Someone standing on the pavement BESIDE a driveway
+ * overlaps the driveway's rectangle in image space with their head and shoulders
+ * while their feet are firmly outside it. Area-overlap answers "yes" and is
+ * wrong; whole-box containment answers "no" for anyone standing at the edge and
+ * is also wrong. Neither is rescued by tuning a fraction, because the error is
+ * not one of degree — the box's top is not where the person IS.
+ *
+ * A camera looks down. The ground plane is where a person occupies space, and
+ * the bottom edge of their box is where they touch it. So `groundContact` — the
+ * bottom-centre point — is the default, and it needs NO threshold: a point is
+ * inside a rectangle or it is not. That is the whole reason to prefer it. A
+ * magic fraction nobody can justify is exactly what this codebase asks not to
+ * invent, and here the physics removes the need for one.
+ *
+ * `areaOverlap` is offered for the cases where the ground plane is not the
+ * subject — a package on a shelf, a vehicle in a wide overhead view — and there
+ * the fraction is a REQUIRED, caller-supplied argument, never a default, so it
+ * appears in the route's own configuration where an operator's expectation can
+ * be compared against it.
+ *
+ * ── COORDINATE SPACES: EXACTLY ONE CONVERSION, HERE ────────────────────────
+ *
+ * Detector boxes are PIXELS in the submitted frame. `sensing_route_screens`
+ * stores `focus_x/y/width/height` NORMALIZED to [0,1] — that is what the portal
+ * writes and what `focusRegionFromScreenRow` reads. The two meet in exactly one
+ * place: this file. Every function takes the frame's dimensions explicitly
+ * rather than carrying a resolution around, because a stale resolution is
+ * silent and a missing argument is not.
+ *
+ * @reuse-audit
+ *   considered: FaceDetector.iou (edge-sensing/src/processors/FaceDetector.ts)
+ *     - not reused: IoU is a SYMMETRIC similarity between two detections, used
+ *       for NMS and tracking. Containment is asymmetric — "how much of the BOX
+ *       is in the RECT" — and IoU's denominator includes the rectangle's own
+ *       area, so a small person inside a large zone scores near zero on IoU and
+ *       1.0 here. Same rectangles, different question. When the detector's own
+ *       NMS lands it must call FaceDetector's iou, not a copy.
+ *   considered: camera-alert-focus-selector.tsx (portal)
+ *     - not reused: drag/clamp only, no containment predicate, and it is React
+ *       in a different package. Its clamping is the reason `assertNormalizedRect`
+ *       can be strict — the rect always arrives already inside [0,1].
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_ZONE_PREDICATE = void 0;
+exports.assertNormalizedRect = assertNormalizedRect;
+exports.normalizeBox = normalizeBox;
+exports.evaluateZone = evaluateZone;
+exports.countInZone = countInZone;
+exports.DEFAULT_ZONE_PREDICATE = { kind: 'groundContact' };
+function assertFinite(n, name) {
+    if (typeof n !== 'number' || !Number.isFinite(n)) {
+        throw new TypeError(`${name} must be a finite number, got ${JSON.stringify(n)}`);
+    }
+}
+/**
+ * A rect outside [0,1] is a COORDINATE-SPACE error, and it must throw.
+ *
+ * The one way this happens is a caller passing pixels where normalized values
+ * belong — and pixels are numerically valid, so the verdict would just be
+ * silently wrong forever: a rect at x=640 clamps to the frame's right edge and
+ * every person reads as outside it. That failure has no symptom other than an
+ * alert that never fires, which is the failure this whole area keeps producing.
+ * Refusing loudly is the only version anybody notices.
+ */
+function assertNormalizedRect(rect) {
+    assertFinite(rect?.x, 'rect.x');
+    assertFinite(rect?.y, 'rect.y');
+    assertFinite(rect?.width, 'rect.width');
+    assertFinite(rect?.height, 'rect.height');
+    if (rect.width <= 0 || rect.height <= 0) {
+        throw new RangeError(`rect must have positive extent, got ${rect.width}x${rect.height}`);
+    }
+    const outOfRange = rect.x < 0 || rect.y < 0 || rect.x + rect.width > 1 + 1e-9 || rect.y + rect.height > 1 + 1e-9;
+    if (outOfRange) {
+        throw new RangeError(`rect must be normalized to [0,1]; got x=${rect.x} y=${rect.y} w=${rect.width} h=${rect.height}. `
+            + 'Pixel coordinates are numerically valid here and would silently never match.');
+    }
+}
+/** Convert a pixel box to normalized coordinates. The only conversion there is. */
+function normalizeBox(box, frame) {
+    assertFinite(frame?.width, 'frame.width');
+    assertFinite(frame?.height, 'frame.height');
+    if (frame.width <= 0 || frame.height <= 0) {
+        throw new RangeError(`frame must have positive extent, got ${frame.width}x${frame.height}`);
+    }
+    assertFinite(box?.x, 'box.x');
+    assertFinite(box?.y, 'box.y');
+    assertFinite(box?.width, 'box.width');
+    assertFinite(box?.height, 'box.height');
+    return {
+        x: box.x / frame.width,
+        y: box.y / frame.height,
+        width: box.width / frame.width,
+        height: box.height / frame.height,
+    };
+}
+/** Area of the intersection of two normalized rects. Zero when disjoint. */
+function intersectionArea(a, b) {
+    const x1 = Math.max(a.x, b.x);
+    const y1 = Math.max(a.y, b.y);
+    const x2 = Math.min(a.x + a.width, b.x + b.width);
+    const y2 = Math.min(a.y + a.height, b.y + b.height);
+    const w = x2 - x1;
+    const h = y2 - y1;
+    return w > 0 && h > 0 ? w * h : 0;
+}
+function pointInRect(px, py, rect) {
+    return px >= rect.x && px <= rect.x + rect.width && py >= rect.y && py <= rect.y + rect.height;
+}
+/**
+ * Is this detection inside the operator's rectangle?
+ *
+ * Throws on a malformed rect or frame — see `assertNormalizedRect`. Never
+ * returns a verdict it could not compute.
+ */
+function evaluateZone(box, frame, rect, predicate = exports.DEFAULT_ZONE_PREDICATE) {
+    assertNormalizedRect(rect);
+    const nb = normalizeBox(box, frame);
+    const boxArea = nb.width * nb.height;
+    const overlapFraction = boxArea > 0 ? intersectionArea(nb, rect) / boxArea : 0;
+    const groundContact = { x: nb.x + nb.width / 2, y: nb.y + nb.height };
+    let inside;
+    if (predicate.kind === 'groundContact') {
+        inside = pointInRect(groundContact.x, groundContact.y, rect);
+    }
+    else {
+        assertFinite(predicate.minOverlap, 'predicate.minOverlap');
+        if (predicate.minOverlap <= 0 || predicate.minOverlap > 1) {
+            throw new RangeError(`minOverlap must be in (0,1], got ${predicate.minOverlap}`);
+        }
+        inside = overlapFraction >= predicate.minOverlap;
+    }
+    return { inside, overlapFraction, groundContact };
+}
+/**
+ * Count the detections inside the zone.
+ *
+ * This is the integer the focused field has been asking a language model for.
+ * `null` rect means NO zone was drawn, and then the count is every detection —
+ * which is what the unfocused field already means, so absence degrades to the
+ * existing behaviour rather than to zero. A zone that silently counts nothing is
+ * indistinguishable from a quiet venue, and that is the whole failure mode here.
+ */
+function countInZone(boxes, frame, rect, predicate = exports.DEFAULT_ZONE_PREDICATE) {
+    if (!rect)
+        return boxes.length;
+    return boxes.reduce((n, b) => (evaluateZone(b, frame, rect, predicate).inside ? n + 1 : n), 0);
+}
+//# sourceMappingURL=zoneContainment.js.map

package/dist/zoneContainment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zoneContainment.js","sourceRoot":"","sources":["../src/zoneContainment.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trillboards/edge-sdk",
-  "version": "0.2.74",
+  "version": "0.2.78",
   "description": "Composable cross-platform Edge AI SDK for audience sensing on DOOH/CTV devices",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,7 +16,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@trillboards/edge-core": "^0.4.0",
+    "@trillboards/edge-core": "^0.4.1",
     "@trillboards/edge-sensing": "^0.2.0",
     "@trillboards/edge-federated": "^0.2.0 || ^1.0.0",
     "@trillboards/edge-ads": "^0.2.0",