supervision 0.2.6 → 0.2.8

package/dist/mask-preparation.worker.js

@@ -1,6 +1,74 @@
 (function () {
     'use strict';
 
+    /** Trace closed pixel boundaries, retaining holes and disconnected components. */
+    function traceMaskOutlinePaths(raster, width, height, ids) {
+        const edgesById = new Map();
+        const stride = width + 1;
+        const steps = [1, stride, -1, -stride];
+        const add = (id, vertex, direction) => {
+            let edges = edgesById.get(id);
+            if (!edges)
+                edgesById.set(id, (edges = new Map()));
+            const outgoing = edges.get(vertex);
+            if (outgoing)
+                outgoing.push(direction);
+            else
+                edges.set(vertex, [direction]);
+        };
+        for (let y = 0; y < height; y += 1) {
+            for (let x = 0; x < width; x += 1) {
+                const offset = y * width + x;
+                const id = raster[offset];
+                if (!ids.has(id))
+                    continue;
+                const vertex = y * stride + x;
+                if (y === 0 || raster[offset - width] !== id)
+                    add(id, vertex, 0);
+                if (x === width - 1 || raster[offset + 1] !== id)
+                    add(id, vertex + 1, 1);
+                if (y === height - 1 || raster[offset + width] !== id)
+                    add(id, vertex + stride + 1, 2);
+                if (x === 0 || raster[offset - 1] !== id)
+                    add(id, vertex + stride, 3);
+            }
+        }
+        const result = new Map();
+        for (const [id, edges] of edgesById) {
+            const paths = [];
+            while (edges.size > 0) {
+                const start = edges.keys().next().value;
+                let vertex = start;
+                let previousDirection = -1;
+                let firstDirection = -1;
+                const points = [];
+                do {
+                    const outgoing = edges.get(vertex);
+                    // Turn right at diagonal contacts so separate islands stay separate.
+                    const direction = previousDirection < 0
+                        ? outgoing[0]
+                        : [1, 0, 3, 2]
+                            .map((turn) => (previousDirection + turn) % 4)
+                            .find((candidate) => outgoing.includes(candidate));
+                    if (firstDirection < 0)
+                        firstDirection = direction;
+                    if (direction !== previousDirection)
+                        points.push(vertex % stride, Math.floor(vertex / stride));
+                    outgoing.splice(outgoing.indexOf(direction), 1);
+                    if (outgoing.length === 0)
+                        edges.delete(vertex);
+                    vertex += steps[direction];
+                    previousDirection = direction;
+                } while (vertex !== start);
+                if (previousDirection === firstDirection)
+                    points.splice(0, 2);
+                paths.push(new Float32Array(points));
+            }
+            result.set(id, paths);
+        }
+        return result;
+    }
+
     /** COCO-compatible keypoint visibility values. */
     var KeypointVisibility;
     (function (KeypointVisibility) {
@@ -895,7 +963,9 @@
     }
     function createIdMaskRasterFrame(instructions, maxRasterWidth) {
         try {
-            return createIdMaskFrame(materializeMaskInstructions(instructions), {
+            return createIdMaskFrame(materializeMaskInstructions(instructions).map((instruction) => instruction.stroke?.widthUnit === "screen"
+                ? { ...instruction, stroke: undefined }
+                : instruction), {
                 maxWidth: maxRasterWidth,
             });
         }
@@ -930,10 +1000,47 @@
     function compositeInstruction(rgba, canvasWidth, instruction) {
         const fill = resolveRgbaColor(instruction.color, instruction.alpha);
         const bounds = compositeMaskFill(rgba, canvasWidth, instruction.mask, fill);
-        if (instruction.stroke && bounds) {
+        if (instruction.stroke &&
+            instruction.stroke.widthUnit !== "screen" &&
+            bounds) {
             compositeMaskStroke(rgba, canvasWidth, decodeCompressedRleMask(instruction.mask), bounds, instruction.stroke);
         }
     }
+    function createMaskScreenStrokes(instructions, width, height, preparedRaster) {
+        const outlined = instructions.filter(({ visible, stroke }) => visible !== false &&
+            stroke?.widthUnit === "screen" &&
+            stroke.width > 0 &&
+            stroke.alpha > 0);
+        if (outlined.length === 0)
+            return undefined;
+        const masks = materializeMaskInstructions(instructions);
+        const raster = preparedRaster ?? new Uint32Array(width * height);
+        if (!preparedRaster) {
+            for (const { detectionIndex, mask } of masks) {
+                const counts = decodeCompressedRleCounts(mask.counts);
+                let offset = 0;
+                for (let index = 0; index < counts.length; index += 1) {
+                    const length = counts[index];
+                    if (index % 2 === 1) {
+                        for (let pixel = offset; pixel < offset + length; pixel += 1) {
+                            const x = Math.floor(pixel / mask.height);
+                            const y = pixel % mask.height;
+                            raster[y * width + x] = detectionIndex + 1;
+                        }
+                    }
+                    offset += length;
+                }
+            }
+        }
+        const paths = traceMaskOutlinePaths(raster, width, height, new Set(outlined.map(({ detectionIndex }) => detectionIndex + 1)));
+        return outlined.map(({ detectionIndex, stroke }) => ({
+            detectionIndex,
+            alpha: stroke.alpha,
+            color: stroke.color,
+            width: stroke.width,
+            paths: paths.get(detectionIndex + 1) ?? [],
+        }));
+    }
     function materializeMaskInstructions(instructions) {
         return instructions
             .filter((instruction) => instruction.visible !== false)
@@ -1788,6 +1895,8 @@
             const coverageTransfers = getRegionMaskCoverageTransfers(regionMaskCoverage);
             const idMaskFrame = createIdMaskRasterFrame(message.job.instructions, message.job.maxRasterWidth);
             if (idMaskFrame) {
+                const screenStrokes = createMaskScreenStrokes(message.job.instructions, idMaskFrame.width, idMaskFrame.height, idMaskFrame.data);
+                const strokeTransfers = screenStrokes?.flatMap(({ paths }) => paths.map((path) => path.buffer)) ?? [];
                 workerScope.postMessage({
                     artifactKind: PreparedMaskFrameKind.IdMask,
                     fillPalette: idMaskFrame.fillPalette,
@@ -1796,6 +1905,7 @@
                     key: message.job.key,
                     maxStrokeWidth: idMaskFrame.maxStrokeWidth,
                     raster: idMaskFrame.data,
+                    screenStrokes,
                     regionMaskCoverage,
                     requestId: message.requestId,
                     sourceWidth: idMaskFrame.sourceWidth,
@@ -1808,6 +1918,7 @@
                     idMaskFrame.fillPalette.buffer,
                     idMaskFrame.strokePalette.buffer,
                     idMaskFrame.strokeWidths.buffer,
+                    ...strokeTransfers,
                     ...coverageTransfers,
                 ]);
                 return;
@@ -1826,25 +1937,40 @@
             const imageBitmap = createImageBitmapFromImageData(imageData);
             const idMaskPlane = createIdMaskPlane(message.job.instructions, message.job.maxRasterWidth);
             const idMaskTransfers = idMaskPlane ? [idMaskPlane.data.buffer] : [];
+            const screenStrokes = createMaskScreenStrokes(message.job.instructions, preparedPixels.width, preparedPixels.height);
+            const strokeTransfers = screenStrokes?.flatMap(({ paths }) => paths.map((path) => path.buffer)) ??
+                [];
             if (imageBitmap) {
                 workerScope.postMessage({
                     idMaskPlane,
                     imageBitmap,
+                    screenStrokes,
                     key: message.job.key,
                     regionMaskCoverage,
                     requestId: message.requestId,
                     type: MaskPreparationWorkerMessageType.Complete,
-                }, [imageBitmap, ...idMaskTransfers, ...coverageTransfers]);
+                }, [
+                    imageBitmap,
+                    ...idMaskTransfers,
+                    ...strokeTransfers,
+                    ...coverageTransfers,
+                ]);
                 return;
             }
             workerScope.postMessage({
                 idMaskPlane,
                 imageData,
+                screenStrokes,
                 key: message.job.key,
                 regionMaskCoverage,
                 requestId: message.requestId,
                 type: MaskPreparationWorkerMessageType.Complete,
-            }, [imageData.data.buffer, ...idMaskTransfers, ...coverageTransfers]);
+            }, [
+                imageData.data.buffer,
+                ...idMaskTransfers,
+                ...strokeTransfers,
+                ...coverageTransfers,
+            ]);
         }
         catch (error) {
             workerScope.postMessage({