scrypted-animal-filter 0.1.0

package/dist/main.d.ts

@@ -0,0 +1,14 @@
+import { ScryptedDeviceBase, MixinProvider, Settings, Setting, ScryptedDeviceType, ScryptedInterface } from '@scrypted/sdk';
+declare class AnimalPersonFilter extends ScryptedDeviceBase implements MixinProvider, Settings {
+    private iouThreshold;
+    private containmentThreshold;
+    constructor(nativeId?: string);
+    getSettings(): Promise<Setting[]>;
+    putSetting(key: string, value: string): Promise<void>;
+    canMixin(type: ScryptedDeviceType, interfaces: string[]): Promise<string[]>;
+    getMixin(mixinDevice: any, mixinDeviceInterfaces: ScryptedInterface[], mixinDeviceState: {
+        [key: string]: any;
+    }): Promise<any>;
+    releaseMixin(id: string, mixinDevice: any): Promise<void>;
+}
+export default AnimalPersonFilter;

package/dist/main.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_1 = require("@scrypted/sdk");
+// ─── IoU Calculation ─────────────────────────────────────────────────
+/**
+ * Compute Intersection over Union between two bounding boxes.
+ * Boxes are [x, y, width, height].
+ */
+function computeIoU(a, b) {
+    const [ax, ay, aw, ah] = a;
+    const [bx, by, bw, bh] = b;
+    const x1 = Math.max(ax, bx);
+    const y1 = Math.max(ay, by);
+    const x2 = Math.min(ax + aw, bx + bw);
+    const y2 = Math.min(ay + ah, by + bh);
+    const intersection = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);
+    if (intersection === 0)
+        return 0;
+    const areaA = aw * ah;
+    const areaB = bw * bh;
+    const union = areaA + areaB - intersection;
+    return union > 0 ? intersection / union : 0;
+}
+/**
+ * Alternative: check if the smaller box is mostly INSIDE the larger one.
+ * This catches cases where the cat bbox is fully contained within the
+ * person bbox (IoU can be low if sizes differ a lot, but containment is high).
+ */
+function computeContainment(inner, outer) {
+    const [ix, iy, iw, ih] = inner;
+    const [ox, oy, ow, oh] = outer;
+    const x1 = Math.max(ix, ox);
+    const y1 = Math.max(iy, oy);
+    const x2 = Math.min(ix + iw, ox + ow);
+    const y2 = Math.min(iy + ih, oy + oh);
+    const intersection = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);
+    const innerArea = iw * ih;
+    return innerArea > 0 ? intersection / innerArea : 0;
+}
+// ─── Animal classes (COCO) ───────────────────────────────────────────
+const ANIMAL_CLASSES = new Set([
+    'cat', 'dog', 'bird', 'horse', 'sheep', 'cow',
+    'elephant', 'bear', 'zebra', 'giraffe',
+]);
+// ─── Mixin (per-camera filter) ───────────────────────────────────────
+class AnimalFilterMixin extends sdk_1.MixinDeviceBase {
+    constructor(options, iouThreshold, containmentThreshold) {
+        super(options);
+        this.suppressedCount = 0;
+        this.iouThreshold = iouThreshold;
+        this.containmentThreshold = containmentThreshold;
+        // Listen to ObjectDetector events on the actual device
+        this.listener = this.mixinDevice.listen(sdk_1.ScryptedInterface.ObjectDetector, (source, details, data) => {
+            this.filterAndForward(data);
+        });
+        this.console.log(`Animal filter active (IoU≥${iouThreshold}, containment≥${containmentThreshold})`);
+    }
+    filterAndForward(detected) {
+        if (!detected?.detections?.length) {
+            // No detections — pass through as-is
+            this.onDeviceEvent(sdk_1.ScryptedInterface.ObjectDetector, detected);
+            return;
+        }
+        const animals = detected.detections.filter(d => d.className && ANIMAL_CLASSES.has(d.className.toLowerCase()));
+        const persons = detected.detections.filter(d => d.className?.toLowerCase() === 'person');
+        const others = detected.detections.filter(d => d.className &&
+            d.className.toLowerCase() !== 'person' &&
+            !ANIMAL_CLASSES.has(d.className.toLowerCase()));
+        // If no animals or no persons, nothing to filter
+        if (!animals.length || !persons.length) {
+            this.onDeviceEvent(sdk_1.ScryptedInterface.ObjectDetector, detected);
+            return;
+        }
+        // Check each person detection against all animal detections
+        const keptPersons = [];
+        let suppressed = 0;
+        for (const person of persons) {
+            const pBox = person.boundingBox;
+            if (!pBox) {
+                keptPersons.push(person);
+                continue;
+            }
+            let overlapsAnimal = false;
+            for (const animal of animals) {
+                const aBox = animal.boundingBox;
+                if (!aBox)
+                    continue;
+                const iou = computeIoU(pBox, aBox);
+                const containment = computeContainment(aBox, pBox);
+                if (iou >= this.iouThreshold || containment >= this.containmentThreshold) {
+                    overlapsAnimal = true;
+                    this.console.log(`Suppressed "person" (${(person.score * 100).toFixed(0)}%) ` +
+                        `overlapping "${animal.className}" (${(animal.score * 100).toFixed(0)}%) — ` +
+                        `IoU=${iou.toFixed(2)}, containment=${containment.toFixed(2)}`);
+                    break;
+                }
+            }
+            if (overlapsAnimal) {
+                suppressed++;
+            }
+            else {
+                keptPersons.push(person);
+            }
+        }
+        if (suppressed > 0) {
+            this.suppressedCount += suppressed;
+            // Rebuild detections without the suppressed persons
+            const filtered = {
+                ...detected,
+                detections: [...keptPersons, ...animals, ...others],
+            };
+            this.onDeviceEvent(sdk_1.ScryptedInterface.ObjectDetector, filtered);
+        }
+        else {
+            // Nothing filtered — pass through
+            this.onDeviceEvent(sdk_1.ScryptedInterface.ObjectDetector, detected);
+        }
+    }
+    async release() {
+        this.listener?.removeListener();
+        this.console.log(`Animal filter released. Suppressed ${this.suppressedCount} false person detections total.`);
+    }
+}
+// ─── Plugin (MixinProvider) ──────────────────────────────────────────
+class AnimalPersonFilter extends sdk_1.ScryptedDeviceBase {
+    constructor(nativeId) {
+        super(nativeId);
+        this.iouThreshold = 0.3;
+        this.containmentThreshold = 0.5;
+        const iou = this.storage.getItem('iouThreshold');
+        if (iou)
+            this.iouThreshold = parseFloat(iou);
+        const cont = this.storage.getItem('containmentThreshold');
+        if (cont)
+            this.containmentThreshold = parseFloat(cont);
+        this.console.log('Animal Person Filter loaded');
+    }
+    // ─── Settings ────────────────────────────────────────────────
+    async getSettings() {
+        return [
+            {
+                key: 'iouThreshold',
+                title: 'IoU Threshold',
+                description: 'Suppress "person" if its IoU with an animal detection exceeds this value. Lower = more aggressive filtering. (default: 0.3)',
+                value: this.iouThreshold.toString(),
+                type: 'number',
+            },
+            {
+                key: 'containmentThreshold',
+                title: 'Containment Threshold',
+                description: 'Suppress "person" if the animal bbox is this much contained inside the person bbox. Catches size-mismatched overlaps. (default: 0.5)',
+                value: this.containmentThreshold.toString(),
+                type: 'number',
+            },
+        ];
+    }
+    async putSetting(key, value) {
+        if (key === 'iouThreshold') {
+            this.iouThreshold = parseFloat(value) || 0.3;
+            this.storage.setItem('iouThreshold', this.iouThreshold.toString());
+        }
+        if (key === 'containmentThreshold') {
+            this.containmentThreshold = parseFloat(value) || 0.5;
+            this.storage.setItem('containmentThreshold', this.containmentThreshold.toString());
+        }
+    }
+    // ─── MixinProvider ───────────────────────────────────────────
+    async canMixin(type, interfaces) {
+        // Only attach to cameras/doorbells that have object detection
+        if ((type === sdk_1.ScryptedDeviceType.Camera || type === sdk_1.ScryptedDeviceType.Doorbell) &&
+            interfaces.includes(sdk_1.ScryptedInterface.ObjectDetector)) {
+            // We provide a filtered ObjectDetector
+            return [sdk_1.ScryptedInterface.ObjectDetector];
+        }
+        return [];
+    }
+    async getMixin(mixinDevice, mixinDeviceInterfaces, mixinDeviceState) {
+        return new AnimalFilterMixin({
+            mixinDevice,
+            mixinDeviceInterfaces,
+            mixinDeviceState: mixinDeviceState,
+            mixinProviderNativeId: this.nativeId,
+        }, this.iouThreshold, this.containmentThreshold);
+    }
+    async releaseMixin(id, mixinDevice) {
+        await mixinDevice.release();
+    }
+}
+exports.default = AnimalPersonFilter;

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "scrypted-animal-filter",
+  "version": "0.1.0",
+  "description": "Suppress false 'person' detections that overlap with animal detections. Fixes cats/dogs being detected as both animal AND person.",
+  "author": "Alan",
+  "license": "MIT",
+  "scrypted": {
+    "name": "Animal Person Filter",
+    "type": "Mixin",
+    "interfaces": [
+      "MixinProvider",
+      "Settings"
+    ]
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "tsc",
+    "scrypted-deploy": "scrypted-deploy"
+  },
+  "dependencies": {
+    "@scrypted/sdk": "^0.3.69"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.0",
+    "@types/node": "^20.0.0"
+  }
+}

package/src/main.ts

@@ -0,0 +1,270 @@
+import sdk, {
+    ScryptedDeviceBase,
+    MixinProvider,
+    MixinDeviceBase,
+    MixinDeviceOptions,
+    Settings,
+    Setting,
+    ScryptedDeviceType,
+    ScryptedInterface,
+    ObjectsDetected,
+    ObjectDetectionResult,
+    EventListenerRegister,
+} from '@scrypted/sdk';
+
+// ─── IoU Calculation ─────────────────────────────────────────────────
+
+/**
+ * Compute Intersection over Union between two bounding boxes.
+ * Boxes are [x, y, width, height].
+ */
+function computeIoU(a: number[], b: number[]): number {
+    const [ax, ay, aw, ah] = a;
+    const [bx, by, bw, bh] = b;
+
+    const x1 = Math.max(ax, bx);
+    const y1 = Math.max(ay, by);
+    const x2 = Math.min(ax + aw, bx + bw);
+    const y2 = Math.min(ay + ah, by + bh);
+
+    const intersection = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);
+    if (intersection === 0) return 0;
+
+    const areaA = aw * ah;
+    const areaB = bw * bh;
+    const union = areaA + areaB - intersection;
+
+    return union > 0 ? intersection / union : 0;
+}
+
+/**
+ * Alternative: check if the smaller box is mostly INSIDE the larger one.
+ * This catches cases where the cat bbox is fully contained within the
+ * person bbox (IoU can be low if sizes differ a lot, but containment is high).
+ */
+function computeContainment(inner: number[], outer: number[]): number {
+    const [ix, iy, iw, ih] = inner;
+    const [ox, oy, ow, oh] = outer;
+
+    const x1 = Math.max(ix, ox);
+    const y1 = Math.max(iy, oy);
+    const x2 = Math.min(ix + iw, ox + ow);
+    const y2 = Math.min(iy + ih, oy + oh);
+
+    const intersection = Math.max(0, x2 - x1) * Math.max(0, y2 - y1);
+    const innerArea = iw * ih;
+
+    return innerArea > 0 ? intersection / innerArea : 0;
+}
+
+// ─── Animal classes (COCO) ───────────────────────────────────────────
+
+const ANIMAL_CLASSES = new Set([
+    'cat', 'dog', 'bird', 'horse', 'sheep', 'cow',
+    'elephant', 'bear', 'zebra', 'giraffe',
+]);
+
+// ─── Mixin (per-camera filter) ───────────────────────────────────────
+
+class AnimalFilterMixin extends MixinDeviceBase<any> {
+    private listener: EventListenerRegister;
+    private iouThreshold: number;
+    private containmentThreshold: number;
+    private suppressedCount: number = 0;
+
+    constructor(
+        options: MixinDeviceOptions<any>,
+        iouThreshold: number,
+        containmentThreshold: number,
+    ) {
+        super(options);
+        this.iouThreshold = iouThreshold;
+        this.containmentThreshold = containmentThreshold;
+
+        // Listen to ObjectDetector events on the actual device
+        this.listener = this.mixinDevice.listen(
+            ScryptedInterface.ObjectDetector,
+            (source, details, data: ObjectsDetected) => {
+                this.filterAndForward(data);
+            }
+        );
+
+        this.console.log(
+            `Animal filter active (IoU≥${iouThreshold}, containment≥${containmentThreshold})`
+        );
+    }
+
+    private filterAndForward(detected: ObjectsDetected) {
+        if (!detected?.detections?.length) {
+            // No detections — pass through as-is
+            this.onDeviceEvent(ScryptedInterface.ObjectDetector, detected);
+            return;
+        }
+
+        const animals = detected.detections.filter(
+            d => d.className && ANIMAL_CLASSES.has(d.className.toLowerCase())
+        );
+        const persons = detected.detections.filter(
+            d => d.className?.toLowerCase() === 'person'
+        );
+        const others = detected.detections.filter(
+            d => d.className &&
+                 d.className.toLowerCase() !== 'person' &&
+                 !ANIMAL_CLASSES.has(d.className.toLowerCase())
+        );
+
+        // If no animals or no persons, nothing to filter
+        if (!animals.length || !persons.length) {
+            this.onDeviceEvent(ScryptedInterface.ObjectDetector, detected);
+            return;
+        }
+
+        // Check each person detection against all animal detections
+        const keptPersons: ObjectDetectionResult[] = [];
+        let suppressed = 0;
+
+        for (const person of persons) {
+            const pBox = person.boundingBox;
+            if (!pBox) {
+                keptPersons.push(person);
+                continue;
+            }
+
+            let overlapsAnimal = false;
+
+            for (const animal of animals) {
+                const aBox = animal.boundingBox;
+                if (!aBox) continue;
+
+                const iou = computeIoU(pBox, aBox);
+                const containment = computeContainment(aBox, pBox);
+
+                if (iou >= this.iouThreshold || containment >= this.containmentThreshold) {
+                    overlapsAnimal = true;
+                    this.console.log(
+                        `Suppressed "person" (${(person.score! * 100).toFixed(0)}%) ` +
+                        `overlapping "${animal.className}" (${(animal.score! * 100).toFixed(0)}%) — ` +
+                        `IoU=${iou.toFixed(2)}, containment=${containment.toFixed(2)}`
+                    );
+                    break;
+                }
+            }
+
+            if (overlapsAnimal) {
+                suppressed++;
+            } else {
+                keptPersons.push(person);
+            }
+        }
+
+        if (suppressed > 0) {
+            this.suppressedCount += suppressed;
+
+            // Rebuild detections without the suppressed persons
+            const filtered: ObjectsDetected = {
+                ...detected,
+                detections: [...keptPersons, ...animals, ...others],
+            };
+
+            this.onDeviceEvent(ScryptedInterface.ObjectDetector, filtered);
+        } else {
+            // Nothing filtered — pass through
+            this.onDeviceEvent(ScryptedInterface.ObjectDetector, detected);
+        }
+    }
+
+    async release() {
+        this.listener?.removeListener();
+        this.console.log(
+            `Animal filter released. Suppressed ${this.suppressedCount} false person detections total.`
+        );
+    }
+}
+
+// ─── Plugin (MixinProvider) ──────────────────────────────────────────
+
+class AnimalPersonFilter extends ScryptedDeviceBase implements MixinProvider, Settings {
+    private iouThreshold: number = 0.3;
+    private containmentThreshold: number = 0.5;
+
+    constructor(nativeId?: string) {
+        super(nativeId);
+
+        const iou = this.storage.getItem('iouThreshold');
+        if (iou) this.iouThreshold = parseFloat(iou);
+
+        const cont = this.storage.getItem('containmentThreshold');
+        if (cont) this.containmentThreshold = parseFloat(cont);
+
+        this.console.log('Animal Person Filter loaded');
+    }
+
+    // ─── Settings ────────────────────────────────────────────────
+
+    async getSettings(): Promise<Setting[]> {
+        return [
+            {
+                key: 'iouThreshold',
+                title: 'IoU Threshold',
+                description: 'Suppress "person" if its IoU with an animal detection exceeds this value. Lower = more aggressive filtering. (default: 0.3)',
+                value: this.iouThreshold.toString(),
+                type: 'number',
+            },
+            {
+                key: 'containmentThreshold',
+                title: 'Containment Threshold',
+                description: 'Suppress "person" if the animal bbox is this much contained inside the person bbox. Catches size-mismatched overlaps. (default: 0.5)',
+                value: this.containmentThreshold.toString(),
+                type: 'number',
+            },
+        ];
+    }
+
+    async putSetting(key: string, value: string): Promise<void> {
+        if (key === 'iouThreshold') {
+            this.iouThreshold = parseFloat(value) || 0.3;
+            this.storage.setItem('iouThreshold', this.iouThreshold.toString());
+        }
+        if (key === 'containmentThreshold') {
+            this.containmentThreshold = parseFloat(value) || 0.5;
+            this.storage.setItem('containmentThreshold', this.containmentThreshold.toString());
+        }
+    }
+
+    // ─── MixinProvider ───────────────────────────────────────────
+
+    async canMixin(type: ScryptedDeviceType, interfaces: string[]): Promise<string[]> {
+        // Only attach to cameras/doorbells that have object detection
+        if (
+            (type === ScryptedDeviceType.Camera || type === ScryptedDeviceType.Doorbell) &&
+            interfaces.includes(ScryptedInterface.ObjectDetector)
+        ) {
+            // We provide a filtered ObjectDetector
+            return [ScryptedInterface.ObjectDetector];
+        }
+        return [];
+    }
+
+    async getMixin(
+        mixinDevice: any,
+        mixinDeviceInterfaces: ScryptedInterface[],
+        mixinDeviceState: { [key: string]: any }
+    ): Promise<any> {
+        return new AnimalFilterMixin(
+            {
+                mixinDevice,
+                mixinDeviceInterfaces,
+                mixinDeviceState: mixinDeviceState as any,
+                mixinProviderNativeId: this.nativeId,
+            } as any,
+            this.iouThreshold,
+            this.containmentThreshold,
+        );
+    }
+
+    async releaseMixin(id: string, mixinDevice: any): Promise<void> {
+        await mixinDevice.release();
+    }
+}
+
+export default AnimalPersonFilter;

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "es2021",
+    "module": "commonjs",
+    "lib": ["es2021"],
+    "declaration": true,
+    "strict": true,
+    "noImplicitAny": false,
+    "strictNullChecks": false,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}