@camstack/vision 0.1.0

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/shared/python-engine.ts"],"sourcesContent":["import type { IInferenceEngine, DetectionRuntime, DetectionDevice } from '@camstack/types'\nimport { spawn, type ChildProcess } from 'node:child_process'\n\nexport class PythonInferenceEngine implements IInferenceEngine {\n  readonly runtime: DetectionRuntime\n  readonly device: DetectionDevice\n  private process: ChildProcess | null = null\n  private receiveBuffer: Buffer = Buffer.alloc(0)\n  private pendingResolve: ((value: Record<string, unknown>) => void) | null = null\n  private pendingReject: ((reason: Error) => void) | null = null\n\n  constructor(\n    private readonly pythonPath: string,\n    runtime: DetectionRuntime,\n    private readonly modelPath: string,\n    private readonly extraArgs: readonly string[] = [],\n  ) {\n    this.runtime = runtime\n    // Determine device from runtime\n    const runtimeDeviceMap: Readonly<Record<DetectionRuntime, DetectionDevice>> = {\n      onnx: 'cpu',\n      coreml: 'gpu-mps',\n      pytorch: 'cpu',\n      openvino: 'cpu',\n      tflite: 'cpu',\n    }\n    this.device = runtimeDeviceMap[runtime]\n  }\n\n  async initialize(): Promise<void> {\n    const args = [this.modelPath, ...this.extraArgs]\n    this.process = spawn(this.pythonPath, args, {\n      stdio: ['pipe', 'pipe', 'pipe'],\n    })\n\n    if (!this.process.stdout || !this.process.stdin) {\n      throw new Error('PythonInferenceEngine: failed to create process pipes')\n    }\n\n    this.process.stderr?.on('data', (chunk: Buffer) => {\n      // Log stderr from python process for debugging\n      process.stderr.write(`[python-engine] ${chunk.toString()}`)\n    })\n\n    this.process.on('error', (err) => {\n      this.pendingReject?.(err)\n      this.pendingReject = null\n      this.pendingResolve = null\n    })\n\n    this.process.on('exit', (code) => {\n      if (code !== 0) {\n        const err = new Error(`PythonInferenceEngine: process exited with code ${code}`)\n        this.pendingReject?.(err)\n        this.pendingReject = null\n        this.pendingResolve = null\n      }\n    })\n\n    this.process.stdout.on('data', (chunk: Buffer) => {\n      this.receiveBuffer = Buffer.concat([this.receiveBuffer, chunk])\n      this._tryReceive()\n    })\n\n    // Give the process a moment to start up and load the model\n    await new Promise<void>((resolve, reject) => {\n      const timeout = setTimeout(() => resolve(), 2000)\n      this.process?.on('error', (err) => {\n        clearTimeout(timeout)\n        reject(err)\n      })\n      this.process?.on('exit', (code) => {\n        clearTimeout(timeout)\n        if (code !== 0) {\n          reject(new Error(`PythonInferenceEngine: process exited early with code ${code}`))\n        }\n      })\n    })\n  }\n\n  private _tryReceive(): void {\n    // Binary IPC: [4 bytes LE uint32 length][JSON bytes]\n    if (this.receiveBuffer.length < 4) return\n\n    const length = this.receiveBuffer.readUInt32LE(0)\n    if (this.receiveBuffer.length < 4 + length) return\n\n    const jsonBytes = this.receiveBuffer.subarray(4, 4 + length)\n    this.receiveBuffer = this.receiveBuffer.subarray(4 + length)\n\n    const resolve = this.pendingResolve\n    const reject = this.pendingReject\n    this.pendingResolve = null\n    this.pendingReject = null\n\n    if (!resolve) return\n\n    try {\n      const parsed = JSON.parse(jsonBytes.toString('utf8')) as Record<string, unknown>\n      resolve(parsed)\n    } catch (err) {\n      reject?.(err instanceof Error ? err : new Error(String(err)))\n    }\n  }\n\n  /** Send JPEG buffer, receive JSON detection results */\n  async runJpeg(jpeg: Buffer): Promise<Record<string, unknown>> {\n    if (!this.process?.stdin) {\n      throw new Error('PythonInferenceEngine: process not initialized')\n    }\n\n    return new Promise<Record<string, unknown>>((resolve, reject) => {\n      this.pendingResolve = resolve\n      this.pendingReject = reject\n\n      // Binary IPC: [4 bytes LE uint32 length][JPEG bytes]\n      const lengthBuf = Buffer.allocUnsafe(4)\n      lengthBuf.writeUInt32LE(jpeg.length, 0)\n      this.process!.stdin!.write(Buffer.concat([lengthBuf, jpeg]))\n    })\n  }\n\n  /** IInferenceEngine.run — wraps runJpeg for compatibility */\n  async run(_input: Float32Array, _inputShape: readonly number[]): Promise<Float32Array> {\n    throw new Error(\n      'PythonInferenceEngine: use runJpeg() directly — this engine operates on JPEG input',\n    )\n  }\n\n  /** IInferenceEngine.runMultiOutput — not supported by Python engine (operates on JPEG input) */\n  async runMultiOutput(\n    _input: Float32Array,\n    _inputShape: readonly number[],\n  ): Promise<Record<string, Float32Array>> {\n    throw new Error(\n      'PythonInferenceEngine: runMultiOutput() is not supported — this engine operates on JPEG input',\n    )\n  }\n\n  async dispose(): Promise<void> {\n    if (this.process) {\n      this.process.stdin?.end()\n      this.process.kill('SIGTERM')\n      this.process = null\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@camstack/vision",
+  "version": "0.1.0",
+  "description": "Builtin detection addons for CamStack — object detection, face, plate, audio, motion",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": { "import": "./dist/index.mjs", "require": "./dist/index.js", "types": "./dist/index.d.ts" },
+    "./addons/*": { "import": "./dist/addons/*/index.mjs", "require": "./dist/addons/*/index.js", "types": "./dist/addons/*/index.d.ts" }
+  },
+  "camstack": {
+    "addons": [
+      { "id": "motion-detection", "entry": "./dist/addons/motion-detection/index.js", "slot": "detector" },
+      { "id": "object-detection", "entry": "./dist/addons/object-detection/index.js", "slot": "detector" },
+      { "id": "face-detection", "entry": "./dist/addons/face-detection/index.js", "slot": "cropper" },
+      { "id": "face-recognition", "entry": "./dist/addons/face-recognition/index.js", "slot": "classifier" },
+      { "id": "plate-detection", "entry": "./dist/addons/plate-detection/index.js", "slot": "cropper" },
+      { "id": "plate-recognition", "entry": "./dist/addons/plate-recognition/index.js", "slot": "classifier" },
+      { "id": "audio-classification", "entry": "./dist/addons/audio-classification/index.js", "slot": "classifier" },
+      { "id": "camera-native-detection", "entry": "./dist/addons/camera-native-detection/index.js", "slot": "detector" },
+      { "id": "bird-global-classifier", "entry": "./dist/addons/bird-global-classifier/index.js", "slot": "classifier" },
+      { "id": "bird-nabirds-classifier", "entry": "./dist/addons/bird-nabirds-classifier/index.js", "slot": "classifier" },
+      { "id": "animal-classifier", "entry": "./dist/addons/animal-classifier/index.js", "slot": "classifier" }
+    ]
+  },
+  "files": ["dist", "python"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "peerDependencies": { "@camstack/types": "^0.1.0" },
+  "dependencies": { "onnxruntime-node": "^1.24.3", "sharp": "^0.34.0" },
+  "devDependencies": {
+    "@camstack/types": "*",
+    "tsup": "^8.0.0",
+    "typescript": "~5.9.0",
+    "vitest": "^3.0.0"
+  }
+}

package/python/coreml_inference.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""CoreML inference script. Binary IPC protocol over stdin/stdout.
+
+Protocol:
+  Send:    [4 bytes LE uint32 length][JPEG bytes]
+  Receive: [4 bytes LE uint32 length][JSON bytes]
+
+Usage:
+  python coreml_inference.py <model_path> [--device cpu|ane|gpu]
+"""
+import sys
+import struct
+import json
+import argparse
+
+
+def read_frame(stream) -> bytes:
+    """Read one JPEG frame from binary IPC stream."""
+    header = stream.read(4)
+    if len(header) < 4:
+        return b""
+    length = struct.unpack("<I", header)[0]
+    data = stream.read(length)
+    return data
+
+
+def write_result(stream, result: dict) -> None:
+    """Write JSON result to binary IPC stream."""
+    payload = json.dumps(result).encode("utf-8")
+    header = struct.pack("<I", len(payload))
+    stream.write(header + payload)
+    stream.flush()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="CoreML inference via binary IPC")
+    parser.add_argument("model_path", help="Path to .mlpackage or .mlmodel")
+    parser.add_argument("--device", default="ane", choices=["cpu", "ane", "gpu"],
+                        help="Compute unit: cpu, ane (Apple Neural Engine), or gpu")
+    args = parser.parse_args()
+
+    # TODO: Load CoreML model
+    # import coremltools as ct
+    # model = ct.models.MLModel(args.model_path)
+
+    stdin_binary = sys.stdin.buffer
+    stdout_binary = sys.stdout.buffer
+
+    # Inference loop
+    while True:
+        jpeg = read_frame(stdin_binary)
+        if not jpeg:
+            break
+
+        # TODO: Run CoreML inference
+        # import PIL.Image, io
+        # img = PIL.Image.open(io.BytesIO(jpeg))
+        # predictions = model.predict({"image": img})
+        # detections = parse_predictions(predictions)
+
+        # Stub: return empty detections
+        result = {"detections": [], "error": None}
+        write_result(stdout_binary, result)
+
+
+if __name__ == "__main__":
+    main()

package/python/openvino_inference.py

@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""OpenVINO inference script. Binary IPC protocol over stdin/stdout.
+
+Protocol:
+  Send:    [4 bytes LE uint32 length][JPEG bytes]
+  Receive: [4 bytes LE uint32 length][JSON bytes]
+
+Usage:
+  python openvino_inference.py <model_path> [--device CPU|GPU|AUTO] [--input-size 640]
+"""
+import sys
+import struct
+import json
+import argparse
+
+
+def read_frame(stream) -> bytes:
+    """Read one JPEG frame from binary IPC stream."""
+    header = stream.read(4)
+    if len(header) < 4:
+        return b""
+    length = struct.unpack("<I", header)[0]
+    data = stream.read(length)
+    return data
+
+
+def write_result(stream, result: dict) -> None:
+    """Write JSON result to binary IPC stream."""
+    payload = json.dumps(result).encode("utf-8")
+    header = struct.pack("<I", len(payload))
+    stream.write(header + payload)
+    stream.flush()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="OpenVINO inference via binary IPC")
+    parser.add_argument("model_path", help="Path to .xml model (IR format)")
+    parser.add_argument("--device", default="AUTO", choices=["CPU", "GPU", "AUTO"],
+                        help="OpenVINO compute device")
+    parser.add_argument("--input-size", type=int, default=640,
+                        help="Model input size (square)")
+    args = parser.parse_args()
+
+    # TODO: Load OpenVINO model
+    # from openvino.runtime import Core
+    # ie = Core()
+    # model = ie.read_model(args.model_path)
+    # compiled = ie.compile_model(model, args.device)
+    # infer_request = compiled.create_infer_request()
+
+    stdin_binary = sys.stdin.buffer
+    stdout_binary = sys.stdout.buffer
+
+    # Inference loop
+    while True:
+        jpeg = read_frame(stdin_binary)
+        if not jpeg:
+            break
+
+        # TODO: Run OpenVINO inference
+        # import io, PIL.Image
+        # import numpy as np
+        # img = PIL.Image.open(io.BytesIO(jpeg)).convert("RGB")
+        # img_resized = img.resize((args.input_size, args.input_size))
+        # img_array = np.array(img_resized).transpose(2, 0, 1)[None].astype(np.float32) / 255.0
+        # infer_request.infer({0: img_array})
+        # output = infer_request.get_output_tensor(0).data
+        # detections = parse_output(output)
+
+        # Stub: return empty detections
+        result = {"detections": [], "error": None}
+        write_result(stdout_binary, result)
+
+
+if __name__ == "__main__":
+    main()

package/python/pytorch_inference.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python3
+"""PyTorch inference script. Binary IPC protocol over stdin/stdout.
+
+Protocol:
+  Send:    [4 bytes LE uint32 length][JPEG bytes]
+  Receive: [4 bytes LE uint32 length][JSON bytes]
+
+Usage:
+  python pytorch_inference.py <model_path> [--device cpu|cuda|mps] [--input-size 640]
+"""
+import sys
+import struct
+import json
+import argparse
+
+
+def read_frame(stream) -> bytes:
+    """Read one JPEG frame from binary IPC stream."""
+    header = stream.read(4)
+    if len(header) < 4:
+        return b""
+    length = struct.unpack("<I", header)[0]
+    data = stream.read(length)
+    return data
+
+
+def write_result(stream, result: dict) -> None:
+    """Write JSON result to binary IPC stream."""
+    payload = json.dumps(result).encode("utf-8")
+    header = struct.pack("<I", len(payload))
+    stream.write(header + payload)
+    stream.flush()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="PyTorch inference via binary IPC")
+    parser.add_argument("model_path", help="Path to .pt or .torchscript model")
+    parser.add_argument("--device", default="cpu", choices=["cpu", "cuda", "mps"],
+                        help="Compute device")
+    parser.add_argument("--input-size", type=int, default=640,
+                        help="Model input size (square)")
+    args = parser.parse_args()
+
+    # TODO: Load PyTorch model
+    # import torch
+    # device = torch.device(args.device)
+    # model = torch.jit.load(args.model_path, map_location=device)
+    # model.eval()
+
+    stdin_binary = sys.stdin.buffer
+    stdout_binary = sys.stdout.buffer
+
+    # Inference loop
+    while True:
+        jpeg = read_frame(stdin_binary)
+        if not jpeg:
+            break
+
+        # TODO: Run PyTorch inference
+        # import io, PIL.Image, torchvision.transforms as T
+        # img = PIL.Image.open(io.BytesIO(jpeg)).convert("RGB")
+        # transform = T.Compose([T.Resize((args.input_size, args.input_size)), T.ToTensor()])
+        # tensor = transform(img).unsqueeze(0).to(device)
+        # with torch.no_grad():
+        #     output = model(tensor)
+        # detections = parse_output(output)
+
+        # Stub: return empty detections
+        result = {"detections": [], "error": None}
+        write_result(stdout_binary, result)
+
+
+if __name__ == "__main__":
+    main()