supervision 0.1.3 → 0.1.5

package/dist/mask-preparation.worker.js

@@ -138,22 +138,56 @@
         AnnotationFrameMutationKind["Update"] = "update";
     })(AnnotationFrameMutationKind || (AnnotationFrameMutationKind = {}));
 
-    var DetectionPickTarget;
-    (function (DetectionPickTarget) {
-        DetectionPickTarget["Box"] = "box";
-        DetectionPickTarget["Edge"] = "edge";
-        DetectionPickTarget["Keypoint"] = "keypoint";
-        DetectionPickTarget["Label"] = "label";
-        DetectionPickTarget["Mask"] = "mask";
-        DetectionPickTarget["Polygon"] = "polygon";
-        DetectionPickTarget["Polyline"] = "polyline";
-    })(DetectionPickTarget || (DetectionPickTarget = {}));
-    var MediaInteractionMode;
-    (function (MediaInteractionMode) {
-        MediaInteractionMode["Always"] = "always";
-        MediaInteractionMode["Disabled"] = "disabled";
-        MediaInteractionMode["PausedOnly"] = "pausedOnly";
-    })(MediaInteractionMode || (MediaInteractionMode = {}));
+    /** Geometry projected into a tracker. The original detection payload is retained. */
+    var TrackingGeometry;
+    (function (TrackingGeometry) {
+        TrackingGeometry["Box"] = "box";
+        TrackingGeometry["Mask"] = "mask";
+        TrackingGeometry["Keypoints"] = "keypoints";
+    })(TrackingGeometry || (TrackingGeometry = {}));
+
+    var DetectionMaskPayloadFormat;
+    (function (DetectionMaskPayloadFormat) {
+        DetectionMaskPayloadFormat["RawCocoRle"] = "rawCocoRle";
+        DetectionMaskPayloadFormat["DeflatedBase64"] = "deflatedBase64";
+    })(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));
+    function encodeBinaryMask(data, width, height) {
+        assertMaskDimensions(data, width, height);
+        const runs = [];
+        let currentValue = 0;
+        let runLength = 0;
+        for (let x = 0; x < width; x += 1) {
+            for (let y = 0; y < height; y += 1) {
+                const value = data[y * width + x] ? 1 : 0;
+                if (value === currentValue) {
+                    runLength += 1;
+                }
+                else {
+                    runs.push(runLength);
+                    currentValue = value;
+                    runLength = 1;
+                }
+            }
+        }
+        runs.push(runLength);
+        return {
+            counts: encodeCompressedRleCounts(runs),
+            encoding: DetectionMaskEncoding.CompressedRle,
+            height,
+            width,
+        };
+    }
+    function assertMaskDimensions(data, width, height) {
+        if (!Number.isInteger(width) || width <= 0) {
+            throw new Error("Mask width must be a positive integer.");
+        }
+        if (!Number.isInteger(height) || height <= 0) {
+            throw new Error("Mask height must be a positive integer.");
+        }
+        if (data.length !== width * height) {
+            throw new Error("Mask data length must equal width * height.");
+        }
+    }
 
     function centerRectToTopLeftRect(rect) {
         return {
@@ -185,6 +219,23 @@
         };
     }
 
+    var DetectionPickTarget;
+    (function (DetectionPickTarget) {
+        DetectionPickTarget["Box"] = "box";
+        DetectionPickTarget["Edge"] = "edge";
+        DetectionPickTarget["Keypoint"] = "keypoint";
+        DetectionPickTarget["Label"] = "label";
+        DetectionPickTarget["Mask"] = "mask";
+        DetectionPickTarget["Polygon"] = "polygon";
+        DetectionPickTarget["Polyline"] = "polyline";
+    })(DetectionPickTarget || (DetectionPickTarget = {}));
+    var MediaInteractionMode;
+    (function (MediaInteractionMode) {
+        MediaInteractionMode["Always"] = "always";
+        MediaInteractionMode["Disabled"] = "disabled";
+        MediaInteractionMode["PausedOnly"] = "pausedOnly";
+    })(MediaInteractionMode || (MediaInteractionMode = {}));
+
     var AnnotationGeometryKind;
     (function (AnnotationGeometryKind) {
         AnnotationGeometryKind["Box"] = "box";
@@ -209,17 +260,19 @@
         AnnotationHandleKind["Keypoint"] = "keypoint";
     })(AnnotationHandleKind || (AnnotationHandleKind = {}));
 
+    /** Alignment for strokes applied to closed rendered geometry. */
+    var StrokeAlignment;
+    (function (StrokeAlignment) {
+        StrokeAlignment["Inside"] = "inside";
+        StrokeAlignment["Center"] = "center";
+        StrokeAlignment["Outside"] = "outside";
+    })(StrokeAlignment || (StrokeAlignment = {}));
+
     var BoxShape;
     (function (BoxShape) {
         BoxShape["Rect"] = "rect";
         BoxShape["RoundedRect"] = "roundedRect";
     })(BoxShape || (BoxShape = {}));
-    var BoxStrokeAlignment;
-    (function (BoxStrokeAlignment) {
-        BoxStrokeAlignment["Inside"] = "inside";
-        BoxStrokeAlignment["Center"] = "center";
-        BoxStrokeAlignment["Outside"] = "outside";
-    })(BoxStrokeAlignment || (BoxStrokeAlignment = {}));
 
     var FocusTargetMode;
     (function (FocusTargetMode) {
@@ -256,54 +309,37 @@
         MaskRenderMode["StrokeOnly"] = "strokeOnly";
     })(MaskRenderMode || (MaskRenderMode = {}));
 
+    /**
+     * Discriminator for renderer-neutral shape draw instructions.
+     */
+    var ShapeInstructionKind;
+    (function (ShapeInstructionKind) {
+        ShapeInstructionKind["Ellipse"] = "ellipse";
+        ShapeInstructionKind["Marker"] = "marker";
+        ShapeInstructionKind["Path"] = "path";
+    })(ShapeInstructionKind || (ShapeInstructionKind = {}));
+    var MarkerShape;
+    (function (MarkerShape) {
+        MarkerShape["Circle"] = "circle";
+        MarkerShape["Cross"] = "cross";
+        MarkerShape["Square"] = "square";
+        MarkerShape["Triangle"] = "triangle";
+    })(MarkerShape || (MarkerShape = {}));
+    /**
+     * Coordinate space for marker sizing. Media sizes scale with the viewport;
+     * screen sizes stay constant on screen, matching stroke-width semantics.
+     */
+    var MarkerSizeSpace;
+    (function (MarkerSizeSpace) {
+        MarkerSizeSpace["Media"] = "media";
+        MarkerSizeSpace["Screen"] = "screen";
+    })(MarkerSizeSpace || (MarkerSizeSpace = {}));
+
     var KeypointMarkerShape;
     (function (KeypointMarkerShape) {
         KeypointMarkerShape["Circle"] = "circle";
         KeypointMarkerShape["Cross"] = "cross";
     })(KeypointMarkerShape || (KeypointMarkerShape = {}));
-
-    var DetectionMaskPayloadFormat;
-    (function (DetectionMaskPayloadFormat) {
-        DetectionMaskPayloadFormat["RawCocoRle"] = "rawCocoRle";
-        DetectionMaskPayloadFormat["DeflatedBase64"] = "deflatedBase64";
-    })(DetectionMaskPayloadFormat || (DetectionMaskPayloadFormat = {}));
-    function encodeBinaryMask(data, width, height) {
-        assertMaskDimensions(data, width, height);
-        const runs = [];
-        let currentValue = 0;
-        let runLength = 0;
-        for (let x = 0; x < width; x += 1) {
-            for (let y = 0; y < height; y += 1) {
-                const value = data[y * width + x] ? 1 : 0;
-                if (value === currentValue) {
-                    runLength += 1;
-                }
-                else {
-                    runs.push(runLength);
-                    currentValue = value;
-                    runLength = 1;
-                }
-            }
-        }
-        runs.push(runLength);
-        return {
-            counts: encodeCompressedRleCounts(runs),
-            encoding: DetectionMaskEncoding.CompressedRle,
-            height,
-            width,
-        };
-    }
-    function assertMaskDimensions(data, width, height) {
-        if (!Number.isInteger(width) || width <= 0) {
-            throw new Error("Mask width must be a positive integer.");
-        }
-        if (!Number.isInteger(height) || height <= 0) {
-            throw new Error("Mask height must be a positive integer.");
-        }
-        if (data.length !== width * height) {
-            throw new Error("Mask data length must equal width * height.");
-        }
-    }
     function rasterizePolygonToMask(points, dimensions) {
         const data = createEmptyMask(dimensions);
         if (points.length < 3) {
@@ -510,8 +546,11 @@
         }
         return { data, height, width };
     }
+    function createMaskIdFrame(instructions) {
+        return createIdMaskFrame(materializeMaskInstructions(instructions));
+    }
     async function createPngIdMaskFrame(instructions) {
-        const frame = createIdMaskFrame(materializeMaskInstructions(instructions));
+        const frame = createMaskIdFrame(instructions);
         if (!frame) {
             return undefined;
         }
@@ -742,21 +781,24 @@
             }
             const imageData = new ImageData(compositedFrame.data, compositedFrame.width, compositedFrame.height);
             const imageBitmap = createImageBitmapFromImageData(imageData);
+            const idMaskData = createMaskIdFrame(message.job.instructions)?.data;
             if (imageBitmap) {
                 workerScope.postMessage({
                     imageBitmap,
+                    idMaskData,
                     key: message.job.key,
                     requestId: message.requestId,
                     type: MaskPreparationWorkerMessageType.Complete,
-                }, [imageBitmap]);
+                }, [...(idMaskData ? [idMaskData.buffer] : []), imageBitmap]);
                 return;
             }
             workerScope.postMessage({
+                idMaskData,
                 imageData,
                 key: message.job.key,
                 requestId: message.requestId,
                 type: MaskPreparationWorkerMessageType.Complete,
-            }, [imageData.data.buffer]);
+            }, [...(idMaskData ? [idMaskData.buffer] : []), imageData.data.buffer]);
         }
         catch (error) {
             workerScope.postMessage({