@luxonis/depthai-viewer-common 3.7.4 → 3.7.6

package/dist/visualizer/messaging/decoder-fixtures.js

@@ -0,0 +1,743 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/
+import { IMUData } from "../protobuf.generated/IMUData.js";
+import { ImageAnnotation, ImageAnnotations, PointsAnnotationType, } from "../protobuf.generated/ImageAnnotations.js";
+import { ImgDetection, ImgDetections } from "../protobuf.generated/ImgDetections.js";
+import { ImgFrame, Type } from "../protobuf.generated/ImgFrame.js";
+import { PointCloudData } from "../protobuf.generated/PointCloudData.js";
+import { SegmentationMask } from "../protobuf.generated/SegmentationMask.js";
+import { SpatialImgDetection, SpatialImgDetections, } from "../protobuf.generated/SpatialImgDetections.js";
+import { getSegmentationClassColor, isTransparentSegmentationClass, } from "../utils/segmentation-colors.js";
+import { runDecoderHarness, } from "./decoder-harness.js";
+import { DEFAULT_BACKGROUND_COLOR, DEFAULT_TEXT_COLOR, } from "./deserialization/detections/constants.js";
+import { protobufs } from "./protobuf.js";
+import { VisualizerPointsAnnotationType } from "./schema-constants.js";
+const DEFAULT_NEURAL_CAMERA_INTRINSICS = {
+    left: {
+        focalLenght: { x: 1, y: 1 },
+        principalPoint: { x: 0.5, y: 0.5 },
+    },
+    right: {
+        focalLenght: { x: 1, y: 1 },
+        principalPoint: { x: 0.5, y: 0.5 },
+    },
+};
+export function getBuiltInDecoderFixtures() {
+    return [
+        {
+            name: "raw-color-image-frame",
+            input: createHarnessInput(protobufs.imageFrame.name, ImgFrame.encode(ImgFrame.fromPartial({
+                ts: { sec: 11, nsec: 22 },
+                fb: {
+                    type: Type.RGB888i,
+                    width: 1,
+                    height: 1,
+                    stride: 3,
+                },
+                data: Uint8Array.from([10, 20, 30]),
+            })).finish()),
+            assertResult: (result) => {
+                assertErrorCount(result, 0);
+                assertEventCount(result, 1);
+                const event = result.events[0];
+                assertEqual(event.topic, "rgb", "raw color topic");
+                assertEqual(event.schemaName, "foxglove.RawImage", "raw color schema");
+                assertTimestamp(event.receiveTime, 11, 22, "raw color receive time");
+                const message = asRecord(event.message);
+                assertEqual(message.frame_id, "color-rgb-frame", "raw color frame id");
+                assertEqual(message.width, 1, "raw color width");
+                assertEqual(message.height, 1, "raw color height");
+                assertEqual(message.encoding, "rgb8", "raw color encoding");
+                assertEqual(message.step, 3, "raw color step");
+                assertEqual(message.stride, 3, "raw color stride");
+                assertEqual(message.planeStride, null, "raw color plane stride");
+                assertUint8Array(message.data, Uint8Array.from([10, 20, 30]), "raw color data");
+            },
+        },
+        {
+            name: "raw-bgr-image-frame-with-stride",
+            input: createHarnessInput(protobufs.imageFrame.name, ImgFrame.encode(ImgFrame.fromPartial({
+                ts: { sec: 12, nsec: 34 },
+                fb: {
+                    type: Type.BGR888i,
+                    width: 2,
+                    height: 1,
+                    stride: 8,
+                },
+                data: Uint8Array.from([1, 2, 3, 4, 5, 6, 0, 0]),
+            })).finish()),
+            assertResult: (result) => {
+                assertErrorCount(result, 0);
+                assertEventCount(result, 1);
+                const event = result.events[0];
+                assertEqual(event.topic, "rgb", "raw bgr topic");
+                assertEqual(event.schemaName, "foxglove.RawImage", "raw bgr schema");
+                assertTimestamp(event.receiveTime, 12, 34, "raw bgr receive time");
+                const message = asRecord(event.message);
+                assertEqual(message.frame_id, "color-rgb-frame", "raw bgr frame id");
+                assertEqual(message.width, 2, "raw bgr width");
+                assertEqual(message.height, 1, "raw bgr height");
+                assertEqual(message.encoding, "bgr8i", "raw bgr encoding");
+                assertEqual(message.step, 8, "raw bgr step");
+                assertEqual(message.stride, 8, "raw bgr stride");
+                assertEqual(message.planeStride, null, "raw bgr plane stride");
+                assertUint8Array(message.data, Uint8Array.from([1, 2, 3, 4, 5, 6, 0, 0]), "raw bgr data");
+            },
+        },
+        {
+            name: "imu-data",
+            input: createHarnessInput(protobufs.imu.name, IMUData.encode(IMUData.fromPartial({
+                ts: { sec: 100, nsec: 200 },
+                tsDevice: { sec: 101, nsec: 300 },
+                packets: [
+                    {
+                        accelerometer: {
+                            vec: { x: 1, y: 2, z: 3 },
+                        },
+                    },
+                ],
+            })).finish()),
+            assertResult: (result) => {
+                assertErrorCount(result, 0);
+                assertEventCount(result, 1);
+                const event = result.events[0];
+                assertEqual(event.topic, "imu", "imu topic");
+                assertEqual(event.schemaName, "foxglove.IMU", "imu schema");
+                assertEqual(event.sizeInBytes, 16, "imu size");
+                assertTimestamp(event.receiveTime, 100, 200, "imu receive time");
+                assertTimestamp(event.publishTime, 101, 300, "imu publish time");
+                const packets = event.message;
+                assertEqual(packets.length, 1, "imu packet count");
+                const packet = asRecord(packets[0]);
+                const accelerometer = asRecord(packet.accelerometer);
+                const vec = asRecord(accelerometer.vec);
+                assertEqual(vec.x, 1, "imu accel x");
+                assertEqual(vec.y, 2, "imu accel y");
+                assertEqual(vec.z, 3, "imu accel z");
+            },
+        },
+        {
+            name: "colored-point-cloud",
+            input: createHarnessInput(protobufs.pointCloud.name, PointCloudData.encode(PointCloudData.fromPartial({
+                ts: { sec: 5, nsec: 6 },
+                color: true,
+                data: createColoredPointCloudSample(),
+            })).finish()),
+            assertResult: (result) => {
+                assertErrorCount(result, 0);
+                assertEventCount(result, 1);
+                const event = result.events[0];
+                assertEqual(event.topic, "pointcloud", "pointcloud topic");
+                assertEqual(event.schemaName, "foxglove.PointCloud.Colored", "pointcloud schema");
+                assertTimestampLike(event.receiveTime, "pointcloud receive time");
+                const message = asRecord(event.message);
+                assertEqual(message.frame_id, "pointcloud-pointcloud-frame", "pointcloud frame id");
+                assertEqual(message.point_stride, 16, "pointcloud stride");
+                assertEqual(message.width, undefined, "pointcloud generic width");
+                assertEqual(message.height, undefined, "pointcloud generic height");
+                assertEqual(message.coordinateFrame, undefined, "pointcloud generic coordinate frame");
+                const fields = message.fields;
+                assertEqual(fields.length, 7, "pointcloud field count");
+                assertEqual(fields[0]?.name, "x", "pointcloud first field");
+                assertEqual(fields[6]?.name, "alpha", "pointcloud alpha field");
+                assertUint8Array(message.data, createColoredPointCloudSample(), "pointcloud data");
+            },
+        },
+        {
+            name: "uncolored-point-cloud",
+            input: createHarnessInput(protobufs.pointCloud.name, PointCloudData.encode(PointCloudData.fromPartial({
+                ts: { sec: 15, nsec: 16 },
+                color: false,
+                data: createUncoloredPointCloudSample(),
+            })).finish()),
+            assertResult: (result) => {
+                assertErrorCount(result, 0);
+                assertEventCount(result, 1);
+                const event = result.events[0];
+                assertEqual(event.topic, "pointcloud", "uncolored pointcloud topic");
+                assertEqual(event.schemaName, "foxglove.PointCloud.Colored", "uncolored pointcloud schema");
+                assertTimestampLike(event.receiveTime, "uncolored pointcloud receive time");
+                const message = asRecord(event.message);
+                assertEqual(message.frame_id, "pointcloud-pointcloud-frame", "uncolored pointcloud frame id");
+                assertEqual(message.point_stride, 12, "uncolored pointcloud stride");
+                assertEqual(message.width, undefined, "uncolored pointcloud generic width");
+                assertEqual(message.height, undefined, "uncolored pointcloud generic height");
+                assertEqual(message.coordinateFrame, undefined, "uncolored pointcloud generic coordinate frame");
+                const fields = message.fields;
+                assertEqual(fields.length, 3, "uncolored pointcloud field count");
+                assertEqual(fields[0]?.name, "x", "uncolored pointcloud first field");
+                assertEqual(fields[2]?.name, "z", "uncolored pointcloud last field");
+                assertUint8Array(message.data, createUncoloredPointCloudSample(), "uncolored pointcloud data");
+            },
+        },
+        {
+            name: "organized-direct-point-cloud",
+            input: createHarnessInput(protobufs.pointCloud.name, PointCloudData.encode(PointCloudData.fromPartial({
+                ts: { sec: 25, nsec: 26 },
+                width: 2,
+                height: 2,
+                sparse: false,
+                color: true,
+                data: createColoredPointCloudSample(4),
+            })).finish()),
+            assertResult: (result) => {
+                assertErrorCount(result, 0);
+                assertEventCount(result, 1);
+                const event = result.events[0];
+                assertEqual(event.topic, "pointcloud", "organized pointcloud topic");
+                assertEqual(event.schemaName, "foxglove.PointCloud.Colored", "organized pointcloud schema");
+                const message = asRecord(event.message);
+                assertEqual(message.point_stride, 16, "organized pointcloud stride");
+                assertEqual(message.width, 2, "organized pointcloud width");
+                assertEqual(message.height, 2, "organized pointcloud height");
+                assertEqual(message.coordinateFrame, "depthai-camera-y-down", "organized pointcloud coordinate frame");
+                assertUint8Array(message.data, createColoredPointCloudSample(4), "organized pointcloud data");
+            },
+        },
+        {
+            name: "sparse-direct-point-cloud-does-not-get-organized-metadata",
+            input: createHarnessInput(protobufs.pointCloud.name, PointCloudData.encode(PointCloudData.fromPartial({
+                ts: { sec: 35, nsec: 36 },
+                width: 2,
+                height: 2,
+                sparse: true,
+                color: true,
+                data: createColoredPointCloudSample(4),
+            })).finish()),
+            assertResult: (result) => {
+                assertErrorCount(result, 0);
+                assertEventCount(result, 1);
+                const message = asRecord(result.events[0].message);
+                assertEqual(message.point_stride, 16, "sparse guarded pointcloud stride");
+                assertEqual(message.width, undefined, "sparse guarded pointcloud width");
+                assertEqual(message.height, undefined, "sparse guarded pointcloud height");
+                assertEqual(message.coordinateFrame, undefined, "sparse guarded pointcloud coordinate frame");
+                assertUint8Array(message.data, createColoredPointCloudSample(4), "sparse guarded pointcloud data");
+            },
+        },
+        {
+            name: "malformed-direct-point-cloud-does-not-get-organized-metadata",
+            input: createHarnessInput(protobufs.pointCloud.name, PointCloudData.encode(PointCloudData.fromPartial({
+                ts: { sec: 45, nsec: 46 },
+                width: 2,
+                height: 2,
+                sparse: false,
+                color: true,
+                data: createColoredPointCloudSample(3),
+            })).finish()),
+            assertResult: (result) => {
+                assertErrorCount(result, 0);
+                assertEventCount(result, 1);
+                const message = asRecord(result.events[0].message);
+                assertEqual(message.point_stride, 16, "malformed guarded pointcloud stride");
+                assertEqual(message.width, undefined, "malformed guarded pointcloud width");
+                assertEqual(message.height, undefined, "malformed guarded pointcloud height");
+                assertEqual(message.coordinateFrame, undefined, "malformed guarded pointcloud coordinate frame");
+                assertUint8Array(message.data, createColoredPointCloudSample(3), "malformed guarded pointcloud data");
+            },
+        },
+        {
+            name: "image-detections",
+            input: createHarnessInput(protobufs.imageDetections.name, ImgDetections.encode(ImgDetections.fromPartial({
+                ts: { sec: 7, nsec: 8 },
+                detections: [
+                    ImgDetection.fromPartial({
+                        label: 2,
+                        confidence: 0.75,
+                        xmin: 0.1,
+                        ymin: 0.2,
+                        xmax: 0.4,
+                        ymax: 0.7,
+                    }),
+                ],
+                transformation: {
+                    width: 200,
+                    height: 100,
+                },
+            })).finish()),
+            assertResult: (result) => {
+                assertErrorCount(result, 0);
+                assertEventCount(result, 1);
+                const event = result.events[0];
+                assertEqual(event.schemaName, "foxglove.ImageAnnotations", "detection schema");
+                assertTimestamp(event.receiveTime, 7, 8, "detection receive time");
+                const message = asRecord(event.message);
+                const points = message.points;
+                const texts = message.texts;
+                const circles = message.circles;
+                assertEqual(points.length, 9, "detection point annotation count");
+                assertEqual(texts.length, 1, "detection text annotation count");
+                assertEqual(circles.length, 0, "detection circle annotation count");
+                const outline = points[0];
+                assertEqual(outline.type, VisualizerPointsAnnotationType.LINE_LOOP, "detection outline type");
+                const outlinePoints = outline.points;
+                assertApprox(outlinePoints[0]?.x, 0.1, 1e-6, "detection outline x0");
+                assertApprox(outlinePoints[0]?.y, 0.2, 1e-6, "detection outline y0");
+                assertApprox(outlinePoints[2]?.x, 0.4, 1e-6, "detection outline x2");
+                assertApprox(outlinePoints[2]?.y, 0.7, 1e-6, "detection outline y2");
+                const text = texts[0];
+                assertEqual(text.text, "Car 75%", "detection label");
+                const textPosition = asRecord(text.position);
+                assertApprox(textPosition.x, 0.1175, 1e-6, "detection label position x");
+                assertApprox(textPosition.y, 0.27, 1e-6, "detection label position y");
+            },
+        },
+        {
+            name: "image-detections-with-segmentation-mask",
+            input: createHarnessInput(protobufs.imageDetections.name, ImgDetections.encode(ImgDetections.fromPartial({
+                ts: { sec: 30, nsec: 31 },
+                tsDevice: { sec: 32, nsec: 33 },
+                detections: [
+                    ImgDetection.fromPartial({
+                        label: 0,
+                        confidence: 0.9,
+                        xmin: 0.1,
+                        ymin: 0.1,
+                        xmax: 0.4,
+                        ymax: 0.4,
+                    }),
+                    ImgDetection.fromPartial({
+                        label: 1,
+                        confidence: 0.8,
+                        xmin: 0.5,
+                        ymin: 0.5,
+                        xmax: 0.8,
+                        ymax: 0.8,
+                    }),
+                ],
+                segmentationMaskWidth: 2,
+                segmentationMaskHeight: 2,
+                maskData: Uint8Array.from([0, 1, 255, 1]),
+                transformation: {
+                    width: 512,
+                    height: 288,
+                },
+            })).finish()),
+            assertResult: (result) => {
+                assertErrorCount(result, 0);
+                assertEventCount(result, 2);
+                const annotationEvent = result.events[0];
+                assertEqual(annotationEvent.schemaName, "foxglove.ImageAnnotations", "detection mask annotation schema");
+                assertTimestamp(annotationEvent.receiveTime, 30, 31, "detection mask receive time");
+                const annotationMessage = asRecord(annotationEvent.message);
+                const points = annotationMessage.points;
+                assertEqual(points.length, 18, "detection mask point annotation count");
+                const detection0Color = getSegmentationClassColor(0);
+                const detection1Color = getSegmentationClassColor(1);
+                if (!detection0Color || !detection1Color) {
+                    throw new Error("detection mask colors should be defined");
+                }
+                assertSegmentationAnnotationColor(points[0]?.outline_color, detection0Color, 1, "detection 0 outline color");
+                assertSegmentationAnnotationColor(points[1]?.outline_color, detection0Color, 1, "detection 0 corner color");
+                assertSegmentationAnnotationColor(points[9]?.outline_color, detection1Color, 1, "detection 1 outline color");
+                assertColorAlpha(points[0]?.fill_color, 0, "detection mask bbox fill alpha");
+                const maskEvent = result.events[1];
+                assertEqual(maskEvent.topic, "detections", "detection mask topic");
+                assertEqual(maskEvent.schemaName, "luxonis.SegmentationMask", "detection mask schema");
+                assertTimestamp(maskEvent.receiveTime, 30, 31, "detection mask receive time");
+                assertTimestamp(maskEvent.publishTime, 32, 33, "detection mask publish time");
+                assertEqual(maskEvent.sizeInBytes, 4, "detection mask size");
+                const message = asRecord(maskEvent.message);
+                assertEqual(message.width, 2, "detection mask width");
+                assertEqual(message.height, 2, "detection mask height");
+                assertEqual(message.bytesPerClassId, 1, "detection mask bytes per class id");
+                assertUint8Array(message.data, Uint8Array.from([0, 1, 255, 1]), "detection mask data");
+                assertDeepEqual(message.labels, [], "detection mask labels");
+                const transformation = asRecord(maskEvent.depthaiTransformation);
+                assertEqual(transformation.width, 512, "detection mask transformation width");
+                assertEqual(transformation.height, 288, "detection mask transformation height");
+            },
+        },
+        {
+            name: "image-detections-invalid-segmentation-mask-byte-length",
+            input: createHarnessInput(protobufs.imageDetections.name, ImgDetections.encode(ImgDetections.fromPartial({
+                ts: { sec: 34, nsec: 35 },
+                detections: [
+                    ImgDetection.fromPartial({
+                        label: 0,
+                        confidence: 0.9,
+                        xmin: 0.1,
+                        ymin: 0.1,
+                        xmax: 0.4,
+                        ymax: 0.4,
+                    }),
+                ],
+                segmentationMaskWidth: 2,
+                segmentationMaskHeight: 2,
+                maskData: Uint8Array.from([0, 1]),
+            })).finish()),
+            assertResult: (result) => {
+                assertEventCount(result, 0);
+                assertErrorCount(result, 1);
+                assertEqual(result.errors[0]?.errorCode, "DecoderError", "detection mask error code");
+                assertEqual(result.errors[0]?.topic, "detections", "detection mask error topic");
+            },
+        },
+        {
+            name: "spatial-image-detections",
+            input: createHarnessInput(protobufs.imageDetectionsSpatial.name, SpatialImgDetections.encode(SpatialImgDetections.fromPartial({
+                ts: { sec: 12, nsec: 34 },
+                detections: [
+                    SpatialImgDetection.fromPartial({
+                        detection: ImgDetection.fromPartial({
+                            label: 1,
+                            confidence: 0.5,
+                            xmin: 0.05,
+                            ymin: 0.15,
+                            xmax: 0.25,
+                            ymax: 0.45,
+                        }),
+                    }),
+                ],
+                transformation: {
+                    width: 320,
+                    height: 240,
+                },
+            })).finish()),
+            assertResult: (result) => {
+                assertErrorCount(result, 0);
+                assertEventCount(result, 1);
+                const event = result.events[0];
+                assertEqual(event.schemaName, "foxglove.ImageAnnotations", "spatial detection schema");
+                assertTimestamp(event.receiveTime, 12, 34, "spatial detection receive time");
+                const message = asRecord(event.message);
+                const points = message.points;
+                const texts = message.texts;
+                assertEqual(points.length, 9, "spatial detection point annotation count");
+                assertEqual(texts.length, 1, "spatial detection text annotation count");
+                assertEqual(texts[0]?.text, "Bicycle 50%", "spatial detection label");
+                const outline = points[0];
+                assertEqual(outline.type, VisualizerPointsAnnotationType.LINE_LOOP, "spatial detection outline type");
+                const outlinePoints = outline.points;
+                assertApprox(outlinePoints[0]?.x, 0.05, 1e-6, "spatial detection outline x0");
+                assertApprox(outlinePoints[0]?.y, 0.15, 1e-6, "spatial detection outline y0");
+                assertApprox(outlinePoints[2]?.x, 0.25, 1e-6, "spatial detection outline x2");
+                assertApprox(outlinePoints[2]?.y, 0.45, 1e-6, "spatial detection outline y2");
+            },
+        },
+        {
+            name: "custom-image-annotations",
+            input: createHarnessInput(protobufs.imageDetectionsCustom.name, ImageAnnotations.encode(ImageAnnotations.fromPartial({
+                ts: { sec: 9, nsec: 10 },
+                transformation: {
+                    width: 100,
+                    height: 200,
+                },
+                annotations: [
+                    ImageAnnotation.fromPartial({
+                        points: [
+                            {
+                                type: PointsAnnotationType.LINE_LIST,
+                                points: [
+                                    { x: 0.1, y: 0.2 },
+                                    { x: 0.3, y: 0.4 },
+                                ],
+                                thickness: 2,
+                            },
+                        ],
+                        texts: [
+                            {
+                                position: { x: 0.5, y: 0.6 },
+                                text: "hello",
+                                fontSize: 12,
+                            },
+                        ],
+                        circles: [
+                            {
+                                position: { x: 0.7, y: 0.8 },
+                                diameter: 0.25,
+                                thickness: 3,
+                            },
+                        ],
+                    }),
+                ],
+            })).finish()),
+            assertResult: (result) => {
+                assertErrorCount(result, 0);
+                assertEventCount(result, 1);
+                const event = result.events[0];
+                assertEqual(event.schemaName, "foxglove.ImageAnnotations", "custom annotations schema");
+                assertTimestamp(event.receiveTime, 9, 10, "custom annotations receive time");
+                const message = asRecord(event.message);
+                const points = message.points;
+                const texts = message.texts;
+                const circles = message.circles;
+                assertEqual(points.length, 1, "custom annotation point count");
+                assertEqual(texts.length, 1, "custom annotation text count");
+                assertEqual(circles.length, 1, "custom annotation circle count");
+                assertEqual(points[0]?.type, PointsAnnotationType.LINE_LIST, "custom annotation point type");
+                assertEqual(texts[0]?.text, "hello", "custom annotation text");
+                assertEqual(texts[0]?.font_size, 12, "custom annotation text size");
+                assertDeepEqual(texts[0]?.text_color, DEFAULT_TEXT_COLOR, "custom annotation default text color");
+                assertDeepEqual(texts[0]?.background_color, DEFAULT_BACKGROUND_COLOR, "custom annotation default background color");
+                assertApprox(circles[0]?.xMultiplier, 2, 1e-6, "custom annotation x multiplier");
+                assertApprox(circles[0]?.yMultiplier, 1, 1e-6, "custom annotation y multiplier");
+            },
+        },
+        {
+            name: "segmentation-mask",
+            input: createHarnessInput(protobufs.segmentationMask.name, SegmentationMask.encode(SegmentationMask.fromPartial({
+                ts: { sec: 20, nsec: 21 },
+                tsDevice: { sec: 22, nsec: 23 },
+                width: 2,
+                height: 2,
+                data: createInt16Bytes([-1, 0, 1, 2]),
+                labels: ["background", "person", "floor"],
+                transformation: {
+                    width: 200,
+                    height: 100,
+                },
+            })).finish()),
+            assertResult: (result) => {
+                assertErrorCount(result, 0);
+                assertEventCount(result, 1);
+                const event = result.events[0];
+                assertEqual(event.topic, "segmentation-mask", "segmentation mask topic");
+                assertEqual(event.schemaName, "luxonis.SegmentationMask", "segmentation mask schema");
+                assertTimestamp(event.receiveTime, 20, 21, "segmentation mask receive time");
+                assertTimestamp(event.publishTime, 22, 23, "segmentation mask publish time");
+                const message = asRecord(event.message);
+                assertEqual(message.width, 2, "segmentation mask width");
+                assertEqual(message.height, 2, "segmentation mask height");
+                assertEqual(message.bytesPerClassId, 2, "segmentation mask bytes per class id");
+                assertUint8Array(message.data, createInt16Bytes([-1, 0, 1, 2]), "segmentation mask data");
+                assertDeepEqual(message.labels, ["background", "person", "floor"], "segmentation mask labels");
+                const transformation = asRecord(event.depthaiTransformation);
+                assertEqual(transformation.width, 200, "segmentation mask transformation width");
+                assertEqual(transformation.height, 100, "segmentation mask transformation height");
+            },
+        },
+        {
+            name: "segmentation-mask-invalid-byte-length",
+            input: createHarnessInput(protobufs.segmentationMask.name, SegmentationMask.encode(SegmentationMask.fromPartial({
+                ts: { sec: 24, nsec: 25 },
+                width: 2,
+                height: 2,
+                data: createInt16Bytes([0]),
+            })).finish()),
+            assertResult: (result) => {
+                assertEventCount(result, 0);
+                assertErrorCount(result, 1);
+                assertEqual(result.errors[0]?.errorCode, "DecoderError", "segmentation mask error code");
+                assertEqual(result.errors[0]?.topic, "segmentation-mask", "segmentation mask error topic");
+            },
+        },
+        {
+            name: "segmentation-mask-uint8-class-ids",
+            input: createHarnessInput(protobufs.segmentationMask.name, SegmentationMask.encode(SegmentationMask.fromPartial({
+                ts: { sec: 26, nsec: 27 },
+                width: 2,
+                height: 2,
+                data: Uint8Array.from([0, 15, 255, 17]),
+                labels: [
+                    "background",
+                    "aeroplane",
+                    "bicycle",
+                    "bird",
+                    "boat",
+                    "bottle",
+                    "bus",
+                    "car",
+                    "cat",
+                    "chair",
+                    "cow",
+                    "diningtable",
+                    "dog",
+                    "horse",
+                    "motorbike",
+                    "person",
+                    "pottedplant",
+                    "sheep",
+                ],
+            })).finish()),
+            assertResult: (result) => {
+                assertErrorCount(result, 0);
+                assertEventCount(result, 1);
+                const event = result.events[0];
+                assertEqual(event.schemaName, "luxonis.SegmentationMask", "uint8 segmentation mask schema");
+                assertTimestamp(event.receiveTime, 26, 27, "uint8 segmentation mask receive time");
+                const message = asRecord(event.message);
+                assertEqual(message.bytesPerClassId, 1, "uint8 segmentation mask bytes per class id");
+                assertUint8Array(message.data, Uint8Array.from([0, 15, 255, 17]), "uint8 segmentation mask data");
+                const labels = message.labels;
+                assertEqual(labels[0], "background", "uint8 segmentation mask background label");
+                assertEqual(labels[15], "person", "uint8 segmentation mask person label");
+                assertEqual(labels[17], "sheep", "uint8 segmentation mask sheep label");
+                assertSegmentationOverlayClassSemantics();
+            },
+        },
+    ];
+}
+export async function runBuiltInDecoderFixtures() {
+    const results = [];
+    for (const fixture of getBuiltInDecoderFixtures()) {
+        const result = await runDecoderHarness(fixture.input);
+        fixture.assertResult(result);
+        results.push({ name: fixture.name, passed: true });
+    }
+    return results;
+}
+function createHarnessInput(schema, bytes) {
+    return {
+        topic: inferTopicFromSchema(schema),
+        schema,
+        buffer: new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength),
+        neuralCameraIntrinsics: DEFAULT_NEURAL_CAMERA_INTRINSICS,
+        stereoDepthMaxValue: 8000,
+    };
+}
+function inferTopicFromSchema(schema) {
+    switch (schema) {
+        case protobufs.imageFrame.name:
+            return "rgb";
+        case protobufs.imu.name:
+            return "imu";
+        case protobufs.pointCloud.name:
+            return "pointcloud";
+        case protobufs.imageDetections.name:
+            return "detections";
+        case protobufs.imageDetectionsSpatial.name:
+            return "detections-spatial";
+        case protobufs.imageDetectionsCustom.name:
+            return "custom-detections";
+        case protobufs.segmentationMask.name:
+            return "segmentation-mask";
+        default:
+            return "fixture-topic";
+    }
+}
+function createInt16Bytes(values) {
+    const bytes = new Uint8Array(values.length * Int16Array.BYTES_PER_ELEMENT);
+    const view = new DataView(bytes.buffer);
+    for (let index = 0; index < values.length; index += 1) {
+        view.setInt16(index * Int16Array.BYTES_PER_ELEMENT, values[index], true);
+    }
+    return bytes;
+}
+function createColoredPointCloudSample(pointCount = 1) {
+    const bytes = new Uint8Array(pointCount * 16);
+    const view = new DataView(bytes.buffer);
+    for (let index = 0; index < pointCount; index += 1) {
+        const offset = index * 16;
+        view.setFloat32(offset, 1 + index, true);
+        view.setFloat32(offset + 4, 2 + index, true);
+        view.setFloat32(offset + 8, 3 + index, true);
+        bytes[offset + 12] = 255;
+        bytes[offset + 13] = 128;
+        bytes[offset + 14] = 64;
+        bytes[offset + 15] = 32;
+    }
+    return bytes;
+}
+function createUncoloredPointCloudSample() {
+    const bytes = new Uint8Array(12);
+    const view = new DataView(bytes.buffer);
+    view.setFloat32(0, 4, true);
+    view.setFloat32(4, 5, true);
+    view.setFloat32(8, 6, true);
+    return bytes;
+}
+function assertSegmentationOverlayClassSemantics() {
+    assertEqual(isTransparentSegmentationClass(-1), true, "segmentation overlay negative class transparency");
+    assertEqual(isTransparentSegmentationClass(255), true, "segmentation overlay class 255 transparency");
+    assertEqual(isTransparentSegmentationClass(0), false, "segmentation overlay class 0 visibility");
+    assertEqual(getSegmentationClassColor(255), undefined, "segmentation overlay class 255 color");
+    const class0Color = getSegmentationClassColor(0);
+    const class15Color = getSegmentationClassColor(15);
+    const class17Color = getSegmentationClassColor(17);
+    if (!class0Color || !class15Color || !class17Color) {
+        throw new Error("segmentation overlay non-background classes should have colors");
+    }
+    assertEqual(class0Color.a, 0.5, "segmentation overlay class 0 alpha");
+    assertEqual(class15Color.a, 0.5, "segmentation overlay class 15 alpha");
+    assertEqual(class17Color.a, 0.5, "segmentation overlay class 17 alpha");
+    assertNotDeepEqual(class0Color, class15Color, "segmentation overlay distinct class 0 and 15 colors");
+    assertNotDeepEqual(class15Color, class17Color, "segmentation overlay distinct class 15 and 17 colors");
+    assertUniqueSegmentationColors();
+}
+function assertUniqueSegmentationColors() {
+    const colorKeys = new Set();
+    for (let classId = 0; classId < 255; classId += 1) {
+        const color = getSegmentationClassColor(classId);
+        if (!color) {
+            throw new Error(`segmentation overlay class ${classId} should have a color`);
+        }
+        const colorKey = `${color.r},${color.g},${color.b}`;
+        if (colorKeys.has(colorKey)) {
+            throw new Error(`segmentation overlay duplicate color ${colorKey}`);
+        }
+        colorKeys.add(colorKey);
+    }
+}
+function assertEventCount(result, expected) {
+    assertEqual(result.events.length, expected, "event count");
+}
+function assertErrorCount(result, expected) {
+    assertEqual(result.errors.length, expected, "error count");
+}
+function assertTimestamp(value, sec, nsec, label) {
+    const record = asRecord(value);
+    assertEqual(record.sec, sec, `${label} sec`);
+    assertEqual(record.nsec, nsec, `${label} nsec`);
+}
+function assertTimestampLike(value, label) {
+    const record = asRecord(value);
+    if (typeof record.sec !== "number" || typeof record.nsec !== "number") {
+        throw new Error(`${label}: expected timestamp-like object`);
+    }
+}
+function assertUint8Array(value, expected, label) {
+    if (!(value instanceof Uint8Array)) {
+        throw new Error(`${label}: expected Uint8Array`);
+    }
+    assertEqual(value.length, expected.length, `${label} length`);
+    for (let i = 0; i < value.length; i++) {
+        assertEqual(value[i], expected[i], `${label}[${i}]`);
+    }
+}
+function assertApprox(value, expected, epsilon, label) {
+    if (typeof value !== "number") {
+        throw new Error(`${label}: expected number, received ${typeof value}`);
+    }
+    if (Math.abs(value - expected) > epsilon) {
+        throw new Error(`${label}: expected ${expected}, received ${value}`);
+    }
+}
+function assertSegmentationAnnotationColor(value, expected, expectedAlpha, label) {
+    const color = asRecord(value);
+    assertApprox(color.r, expected.r / 255, 1e-6, `${label} red`);
+    assertApprox(color.g, expected.g / 255, 1e-6, `${label} green`);
+    assertApprox(color.b, expected.b / 255, 1e-6, `${label} blue`);
+    assertApprox(color.a, expectedAlpha, 1e-6, `${label} alpha`);
+}
+function assertColorAlpha(value, expectedAlpha, label) {
+    const color = asRecord(value);
+    assertApprox(color.a, expectedAlpha, 1e-6, label);
+}
+function assertEqual(value, expected, label) {
+    if (value !== expected) {
+        throw new Error(`${label}: expected ${String(expected)}, received ${String(value)}`);
+    }
+}
+function assertDeepEqual(value, expected, label) {
+    const actualJson = JSON.stringify(value);
+    const expectedJson = JSON.stringify(expected);
+    if (actualJson !== expectedJson) {
+        throw new Error(`${label}: expected ${expectedJson}, received ${actualJson}`);
+    }
+}
+function assertNotDeepEqual(value, expected, label) {
+    const actualJson = JSON.stringify(value);
+    const expectedJson = JSON.stringify(expected);
+    if (actualJson === expectedJson) {
+        throw new Error(`${label}: expected values to differ, received ${actualJson}`);
+    }
+}
+function asRecord(value) {
+    if (!value || typeof value !== "object") {
+        throw new Error(`Expected object, received ${String(value)}`);
+    }
+    return value;
+}
+//# sourceMappingURL=decoder-fixtures.js.map