@camstack/vision 0.1.0

package/dist/addons/object-detection/index.js

@@ -0,0 +1,673 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/addons/object-detection/index.ts
+var object_detection_exports = {};
+__export(object_detection_exports, {
+  default: () => ObjectDetectionAddon
+});
+module.exports = __toCommonJS(object_detection_exports);
+var import_types = require("@camstack/types");
+
+// src/shared/image-utils.ts
+var import_sharp = __toESM(require("sharp"));
+async function letterbox(jpeg, targetSize) {
+  const meta = await (0, import_sharp.default)(jpeg).metadata();
+  const originalWidth = meta.width ?? 0;
+  const originalHeight = meta.height ?? 0;
+  const scale = Math.min(targetSize / originalWidth, targetSize / originalHeight);
+  const scaledWidth = Math.round(originalWidth * scale);
+  const scaledHeight = Math.round(originalHeight * scale);
+  const padX = Math.floor((targetSize - scaledWidth) / 2);
+  const padY = Math.floor((targetSize - scaledHeight) / 2);
+  const { data } = await (0, import_sharp.default)(jpeg).resize(scaledWidth, scaledHeight).extend({
+    top: padY,
+    bottom: targetSize - scaledHeight - padY,
+    left: padX,
+    right: targetSize - scaledWidth - padX,
+    background: { r: 114, g: 114, b: 114 }
+  }).removeAlpha().raw().toBuffer({ resolveWithObject: true });
+  const numPixels = targetSize * targetSize;
+  const float32 = new Float32Array(3 * numPixels);
+  for (let i = 0; i < numPixels; i++) {
+    const srcBase = i * 3;
+    float32[0 * numPixels + i] = data[srcBase] / 255;
+    float32[1 * numPixels + i] = data[srcBase + 1] / 255;
+    float32[2 * numPixels + i] = data[srcBase + 2] / 255;
+  }
+  return { data: float32, scale, padX, padY, originalWidth, originalHeight };
+}
+
+// src/shared/postprocess/yolo.ts
+function iou(a, b) {
+  const ax1 = a.x;
+  const ay1 = a.y;
+  const ax2 = a.x + a.w;
+  const ay2 = a.y + a.h;
+  const bx1 = b.x;
+  const by1 = b.y;
+  const bx2 = b.x + b.w;
+  const by2 = b.y + b.h;
+  const interX1 = Math.max(ax1, bx1);
+  const interY1 = Math.max(ay1, by1);
+  const interX2 = Math.min(ax2, bx2);
+  const interY2 = Math.min(ay2, by2);
+  const interW = Math.max(0, interX2 - interX1);
+  const interH = Math.max(0, interY2 - interY1);
+  const interArea = interW * interH;
+  if (interArea === 0) return 0;
+  const areaA = a.w * a.h;
+  const areaB = b.w * b.h;
+  const unionArea = areaA + areaB - interArea;
+  return unionArea === 0 ? 0 : interArea / unionArea;
+}
+function nms(boxes, iouThreshold) {
+  const indices = boxes.map((_, i) => i).sort((a, b) => boxes[b].score - boxes[a].score);
+  const kept = [];
+  const suppressed = /* @__PURE__ */ new Set();
+  for (const idx of indices) {
+    if (suppressed.has(idx)) continue;
+    kept.push(idx);
+    for (const other of indices) {
+      if (other === idx || suppressed.has(other)) continue;
+      if (iou(boxes[idx].bbox, boxes[other].bbox) > iouThreshold) {
+        suppressed.add(other);
+      }
+    }
+  }
+  return kept;
+}
+function yoloPostprocess(output, numClasses, numBoxes, options) {
+  const { confidence, iouThreshold, labels, scale, padX, padY, originalWidth, originalHeight } = options;
+  const candidates = [];
+  for (let i = 0; i < numBoxes; i++) {
+    const cx = output[0 * numBoxes + i];
+    const cy = output[1 * numBoxes + i];
+    const w = output[2 * numBoxes + i];
+    const h = output[3 * numBoxes + i];
+    let bestScore = -Infinity;
+    let bestClass = 0;
+    for (let j = 0; j < numClasses; j++) {
+      const score = output[(4 + j) * numBoxes + i];
+      if (score > bestScore) {
+        bestScore = score;
+        bestClass = j;
+      }
+    }
+    if (bestScore < confidence) continue;
+    const bbox = {
+      x: cx - w / 2,
+      y: cy - h / 2,
+      w,
+      h
+    };
+    candidates.push({ bbox, score: bestScore, classIdx: bestClass });
+  }
+  if (candidates.length === 0) return [];
+  const keptIndices = nms(candidates, iouThreshold);
+  return keptIndices.map((idx) => {
+    const { bbox, score, classIdx } = candidates[idx];
+    const label = labels[classIdx] ?? String(classIdx);
+    const x = Math.max(0, Math.min(originalWidth, (bbox.x - padX) / scale));
+    const y = Math.max(0, Math.min(originalHeight, (bbox.y - padY) / scale));
+    const x2 = Math.max(0, Math.min(originalWidth, (bbox.x + bbox.w - padX) / scale));
+    const y2 = Math.max(0, Math.min(originalHeight, (bbox.y + bbox.h - padY) / scale));
+    const finalBbox = { x, y, w: x2 - x, h: y2 - y };
+    return {
+      class: label,
+      originalClass: label,
+      score,
+      bbox: finalBbox
+    };
+  });
+}
+
+// src/shared/postprocess/yolo-seg.ts
+function sigmoid(x) {
+  return 1 / (1 + Math.exp(-x));
+}
+function computeRawMask(coeffs, protos, numMaskCoeffs, maskH, maskW) {
+  const maskSize = maskH * maskW;
+  const rawMask = new Float32Array(maskSize);
+  for (let px = 0; px < maskSize; px++) {
+    let val = 0;
+    for (let k = 0; k < numMaskCoeffs; k++) {
+      val += (coeffs[k] ?? 0) * (protos[k * maskSize + px] ?? 0);
+    }
+    rawMask[px] = sigmoid(val);
+  }
+  return rawMask;
+}
+function cropAndThresholdMask(rawMask, maskH, maskW, bbox, maskThreshold, maskScale) {
+  const cropX1 = Math.max(0, Math.floor(bbox.x * maskScale));
+  const cropY1 = Math.max(0, Math.floor(bbox.y * maskScale));
+  const cropX2 = Math.min(maskW, Math.ceil((bbox.x + bbox.w) * maskScale));
+  const cropY2 = Math.min(maskH, Math.ceil((bbox.y + bbox.h) * maskScale));
+  const cropW = Math.max(1, cropX2 - cropX1);
+  const cropH = Math.max(1, cropY2 - cropY1);
+  const data = new Uint8Array(cropW * cropH);
+  for (let row = 0; row < cropH; row++) {
+    const srcRow = cropY1 + row;
+    for (let col = 0; col < cropW; col++) {
+      const srcCol = cropX1 + col;
+      const srcIdx = srcRow * maskW + srcCol;
+      data[row * cropW + col] = (rawMask[srcIdx] ?? 0) > maskThreshold ? 255 : 0;
+    }
+  }
+  return { data, width: cropW, height: cropH };
+}
+function yoloSegPostprocess(segOutput, options) {
+  const {
+    detectionOutput,
+    protoOutput,
+    numClasses,
+    numBoxes,
+    numMaskCoeffs,
+    maskHeight,
+    maskWidth
+  } = segOutput;
+  const {
+    confidence,
+    iouThreshold,
+    labels,
+    scale,
+    padX,
+    padY,
+    originalWidth,
+    originalHeight,
+    maskThreshold = 0.5
+  } = options;
+  const yoloInputSize = 640;
+  const maskScale = maskHeight / yoloInputSize;
+  const candidates = [];
+  for (let i = 0; i < numBoxes; i++) {
+    const cx = detectionOutput[0 * numBoxes + i] ?? 0;
+    const cy = detectionOutput[1 * numBoxes + i] ?? 0;
+    const w = detectionOutput[2 * numBoxes + i] ?? 0;
+    const h = detectionOutput[3 * numBoxes + i] ?? 0;
+    let bestScore = -Infinity;
+    let bestClass = 0;
+    for (let j = 0; j < numClasses; j++) {
+      const score = detectionOutput[(4 + j) * numBoxes + i] ?? 0;
+      if (score > bestScore) {
+        bestScore = score;
+        bestClass = j;
+      }
+    }
+    if (bestScore < confidence) continue;
+    const bbox = {
+      x: cx - w / 2,
+      y: cy - h / 2,
+      w,
+      h
+    };
+    const coeffs = new Float32Array(numMaskCoeffs);
+    for (let k = 0; k < numMaskCoeffs; k++) {
+      coeffs[k] = detectionOutput[(4 + numClasses + k) * numBoxes + i] ?? 0;
+    }
+    candidates.push({ bbox, score: bestScore, classIdx: bestClass, coeffs });
+  }
+  if (candidates.length === 0) return [];
+  const keptIndices = nms(candidates, iouThreshold);
+  return keptIndices.map((idx) => {
+    const { bbox, score, classIdx, coeffs } = candidates[idx];
+    const label = labels[classIdx] ?? String(classIdx);
+    const x = Math.max(0, Math.min(originalWidth, (bbox.x - padX) / scale));
+    const y = Math.max(0, Math.min(originalHeight, (bbox.y - padY) / scale));
+    const x2 = Math.max(0, Math.min(originalWidth, (bbox.x + bbox.w - padX) / scale));
+    const y2 = Math.max(0, Math.min(originalHeight, (bbox.y + bbox.h - padY) / scale));
+    const finalBbox = { x, y, w: x2 - x, h: y2 - y };
+    const rawMask = computeRawMask(coeffs, protoOutput, numMaskCoeffs, maskHeight, maskWidth);
+    const { data: maskData, width: mW, height: mH } = cropAndThresholdMask(
+      rawMask,
+      maskHeight,
+      maskWidth,
+      bbox,
+      maskThreshold,
+      maskScale
+    );
+    return {
+      class: label,
+      originalClass: label,
+      score,
+      bbox: finalBbox,
+      mask: maskData,
+      maskWidth: mW,
+      maskHeight: mH
+    };
+  });
+}
+
+// src/shared/engine-resolver.ts
+var fs = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+
+// src/shared/node-engine.ts
+var path = __toESM(require("path"));
+var BACKEND_TO_PROVIDER = {
+  cpu: "cpu",
+  coreml: "coreml",
+  cuda: "cuda",
+  tensorrt: "tensorrt",
+  dml: "dml"
+};
+var BACKEND_TO_DEVICE = {
+  cpu: "cpu",
+  coreml: "gpu-mps",
+  cuda: "gpu-cuda",
+  tensorrt: "tensorrt"
+};
+var NodeInferenceEngine = class {
+  constructor(modelPath, backend) {
+    this.modelPath = modelPath;
+    this.backend = backend;
+    this.device = BACKEND_TO_DEVICE[backend] ?? "cpu";
+  }
+  runtime = "onnx";
+  device;
+  session = null;
+  async initialize() {
+    const ort = await import("onnxruntime-node");
+    const provider = BACKEND_TO_PROVIDER[this.backend] ?? "cpu";
+    const absModelPath = path.isAbsolute(this.modelPath) ? this.modelPath : path.resolve(process.cwd(), this.modelPath);
+    const sessionOptions = {
+      executionProviders: [provider]
+    };
+    this.session = await ort.InferenceSession.create(absModelPath, sessionOptions);
+  }
+  async run(input, inputShape) {
+    if (!this.session) {
+      throw new Error("NodeInferenceEngine: not initialized \u2014 call initialize() first");
+    }
+    const ort = await import("onnxruntime-node");
+    const sess = this.session;
+    const inputName = sess.inputNames[0];
+    const tensor = new ort.Tensor("float32", input, [...inputShape]);
+    const feeds = { [inputName]: tensor };
+    const results = await sess.run(feeds);
+    const outputName = sess.outputNames[0];
+    const outputTensor = results[outputName];
+    return outputTensor.data;
+  }
+  async runMultiOutput(input, inputShape) {
+    if (!this.session) {
+      throw new Error("NodeInferenceEngine: not initialized \u2014 call initialize() first");
+    }
+    const ort = await import("onnxruntime-node");
+    const sess = this.session;
+    const inputName = sess.inputNames[0];
+    const tensor = new ort.Tensor("float32", input, [...inputShape]);
+    const feeds = { [inputName]: tensor };
+    const results = await sess.run(feeds);
+    const out = {};
+    for (const name of sess.outputNames) {
+      out[name] = results[name].data;
+    }
+    return out;
+  }
+  async dispose() {
+    this.session = null;
+  }
+};
+
+// src/shared/engine-resolver.ts
+var AUTO_BACKEND_PRIORITY = ["coreml", "cuda", "tensorrt", "cpu"];
+var BACKEND_TO_FORMAT = {
+  cpu: "onnx",
+  coreml: "coreml",
+  cuda: "onnx",
+  tensorrt: "onnx"
+};
+var RUNTIME_TO_FORMAT = {
+  onnx: "onnx",
+  coreml: "coreml",
+  openvino: "openvino",
+  tflite: "tflite",
+  pytorch: "pt"
+};
+function modelFilePath(modelsDir, modelEntry, format) {
+  const formatEntry = modelEntry.formats[format];
+  if (!formatEntry) {
+    throw new Error(`Model ${modelEntry.id} has no ${format} format`);
+  }
+  const urlParts = formatEntry.url.split("/");
+  const filename = urlParts[urlParts.length - 1] ?? `${modelEntry.id}.${format}`;
+  return path2.join(modelsDir, filename);
+}
+function modelExists(filePath) {
+  try {
+    return fs.existsSync(filePath);
+  } catch {
+    return false;
+  }
+}
+async function resolveEngine(options) {
+  const { runtime, backend, modelEntry, modelsDir, downloadModel } = options;
+  let selectedFormat;
+  let selectedBackend;
+  if (runtime === "auto") {
+    const available = await probeOnnxBackends();
+    let chosen = null;
+    for (const b of AUTO_BACKEND_PRIORITY) {
+      if (!available.includes(b)) continue;
+      const fmt = BACKEND_TO_FORMAT[b];
+      if (!fmt) continue;
+      if (!modelEntry.formats[fmt]) continue;
+      chosen = { backend: b, format: fmt };
+      break;
+    }
+    if (!chosen) {
+      throw new Error(
+        `resolveEngine: no compatible backend found for model ${modelEntry.id}. Available backends: ${available.join(", ")}`
+      );
+    }
+    selectedFormat = chosen.format;
+    selectedBackend = chosen.backend;
+  } else {
+    const fmt = RUNTIME_TO_FORMAT[runtime];
+    if (!fmt) {
+      throw new Error(`resolveEngine: unsupported runtime "${runtime}"`);
+    }
+    if (!modelEntry.formats[fmt]) {
+      throw new Error(
+        `resolveEngine: model ${modelEntry.id} has no ${fmt} format for runtime ${runtime}`
+      );
+    }
+    selectedFormat = fmt;
+    selectedBackend = runtime === "onnx" ? backend || "cpu" : runtime;
+  }
+  let modelPath = modelFilePath(modelsDir, modelEntry, selectedFormat);
+  if (!modelExists(modelPath)) {
+    if (downloadModel) {
+      const formatEntry = modelEntry.formats[selectedFormat];
+      modelPath = await downloadModel(formatEntry.url, modelsDir);
+    } else {
+      throw new Error(
+        `resolveEngine: model file not found at ${modelPath} and no downloadModel function provided`
+      );
+    }
+  }
+  if (selectedFormat === "onnx" || selectedFormat === "coreml") {
+    const engine = new NodeInferenceEngine(modelPath, selectedBackend);
+    await engine.initialize();
+    return { engine, format: selectedFormat, modelPath };
+  }
+  const fallbackPath = modelFilePath(modelsDir, modelEntry, "onnx");
+  if (modelEntry.formats["onnx"] && modelExists(fallbackPath)) {
+    const engine = new NodeInferenceEngine(fallbackPath, "cpu");
+    await engine.initialize();
+    return { engine, format: "onnx", modelPath: fallbackPath };
+  }
+  throw new Error(
+    `resolveEngine: format ${selectedFormat} is not yet supported by NodeInferenceEngine and no ONNX fallback is available`
+  );
+}
+async function probeOnnxBackends() {
+  const available = ["cpu"];
+  try {
+    const ort = await import("onnxruntime-node");
+    const providers = ort.env?.webgl?.disabled !== void 0 ? ort.InferenceSession?.getAvailableProviders?.() ?? [] : [];
+    for (const p of providers) {
+      const normalized = p.toLowerCase().replace("executionprovider", "");
+      if (normalized === "coreml") available.push("coreml");
+      else if (normalized === "cuda") available.push("cuda");
+      else if (normalized === "tensorrt") available.push("tensorrt");
+    }
+  } catch {
+  }
+  if (process.platform === "darwin" && !available.includes("coreml")) {
+    available.push("coreml");
+  }
+  return [...new Set(available)];
+}
+
+// src/addons/object-detection/index.ts
+function isSegModel(modelId) {
+  return modelId.includes("-seg");
+}
+var ALL_DETECTION_MODELS = [
+  ...import_types.OBJECT_DETECTION_MODELS,
+  ...import_types.SEGMENTATION_MODELS
+];
+function applyClassMap(detections, classMap) {
+  return detections.filter((d) => classMap.mapping[d.class] !== void 0).map((d) => ({
+    ...d,
+    originalClass: d.class,
+    class: classMap.mapping[d.class]
+  }));
+}
+var ObjectDetectionAddon = class {
+  id = "object-detection";
+  slot = "detector";
+  inputClasses = null;
+  outputClasses = ["person", "vehicle", "animal"];
+  slotPriority = 0;
+  manifest = {
+    id: "object-detection",
+    name: "Object Detection",
+    version: "0.1.0",
+    description: "YOLO-based object detection \u2014 detects persons, vehicles, and animals",
+    packageName: "@camstack/vision",
+    slot: "detector",
+    inputClasses: void 0,
+    outputClasses: ["person", "vehicle", "animal"],
+    supportsCustomModels: true,
+    mayRequirePython: false,
+    defaultConfig: {
+      modelId: "yolov8n",
+      runtime: "auto",
+      backend: "cpu",
+      confidence: 0.5,
+      iouThreshold: 0.45
+    }
+  };
+  engine;
+  modelEntry;
+  confidence = 0.5;
+  iouThreshold = 0.45;
+  async initialize(ctx) {
+    const cfg = ctx.addonConfig;
+    const modelId = cfg["modelId"] ?? "yolov8n";
+    const runtime = cfg["runtime"] ?? "auto";
+    const backend = cfg["backend"] ?? "cpu";
+    this.confidence = cfg["confidence"] ?? 0.5;
+    this.iouThreshold = cfg["iouThreshold"] ?? 0.45;
+    const entry = ALL_DETECTION_MODELS.find((m) => m.id === modelId);
+    if (!entry) {
+      throw new Error(`ObjectDetectionAddon: unknown modelId "${modelId}"`);
+    }
+    this.modelEntry = entry;
+    const resolved = await resolveEngine({
+      runtime,
+      backend,
+      modelEntry: entry,
+      modelsDir: ctx.locationPaths.models
+    });
+    this.engine = resolved.engine;
+  }
+  async detect(frame) {
+    const start = Date.now();
+    const { width: inputW, height: inputH } = this.modelEntry.inputSize;
+    const targetSize = Math.max(inputW, inputH);
+    const lb = await letterbox(frame.data, targetSize);
+    const numClasses = this.modelEntry.labels.length;
+    const labels = this.modelEntry.labels.map((l) => l.id);
+    const postprocessOpts = {
+      confidence: this.confidence,
+      iouThreshold: this.iouThreshold,
+      labels,
+      scale: lb.scale,
+      padX: lb.padX,
+      padY: lb.padY,
+      originalWidth: lb.originalWidth,
+      originalHeight: lb.originalHeight
+    };
+    let rawDetections;
+    if (isSegModel(this.modelEntry.id)) {
+      const outputs = await this.engine.runMultiOutput(lb.data, [1, 3, targetSize, targetSize]);
+      const outputNames = Object.keys(outputs);
+      if (outputNames.length < 2) {
+        throw new Error(
+          `ObjectDetectionAddon: seg model "${this.modelEntry.id}" returned ${outputNames.length} output(s); expected 2`
+        );
+      }
+      const detectionOutput = outputs[outputNames[0]];
+      const protoOutput = outputs[outputNames[1]];
+      const numMaskCoeffs = 32;
+      const numBoxes = detectionOutput.length / (4 + numClasses + numMaskCoeffs);
+      const maskHeight = 160;
+      const maskWidth = 160;
+      rawDetections = yoloSegPostprocess(
+        {
+          detectionOutput,
+          protoOutput,
+          numClasses,
+          numBoxes,
+          numMaskCoeffs,
+          maskHeight,
+          maskWidth
+        },
+        postprocessOpts
+      );
+    } else {
+      const output = await this.engine.run(lb.data, [1, 3, targetSize, targetSize]);
+      const numBoxes = output.length / (4 + numClasses);
+      rawDetections = yoloPostprocess(output, numClasses, numBoxes, postprocessOpts);
+    }
+    const detections = applyClassMap(rawDetections, import_types.COCO_TO_MACRO);
+    return {
+      detections,
+      inferenceMs: Date.now() - start,
+      modelId: this.modelEntry.id
+    };
+  }
+  async shutdown() {
+    await this.engine?.dispose();
+  }
+  getConfigSchema() {
+    return {
+      sections: [
+        {
+          id: "model",
+          title: "Model",
+          columns: 2,
+          fields: [
+            {
+              key: "modelId",
+              label: "Model",
+              type: "model-selector",
+              catalog: [...ALL_DETECTION_MODELS],
+              allowCustom: true,
+              allowConversion: true,
+              acceptFormats: ["onnx", "coreml", "openvino", "tflite"],
+              requiredMetadata: ["inputSize", "labels", "outputFormat"],
+              outputFormatHint: "yolo"
+            }
+          ]
+        },
+        {
+          id: "runtime",
+          title: "Runtime",
+          columns: 2,
+          fields: [
+            {
+              key: "runtime",
+              label: "Runtime",
+              type: "select",
+              options: [
+                { value: "auto", label: "Auto (recommended)" },
+                { value: "onnx", label: "ONNX Runtime" },
+                { value: "coreml", label: "CoreML (Apple)" },
+                { value: "openvino", label: "OpenVINO (Intel)" }
+              ]
+            },
+            {
+              key: "backend",
+              label: "Backend",
+              type: "select",
+              dependsOn: { runtime: "onnx" },
+              options: [
+                { value: "cpu", label: "CPU" },
+                { value: "coreml", label: "CoreML" },
+                { value: "cuda", label: "CUDA (NVIDIA)" },
+                { value: "tensorrt", label: "TensorRT (NVIDIA)" }
+              ]
+            }
+          ]
+        },
+        {
+          id: "thresholds",
+          title: "Detection Thresholds",
+          columns: 2,
+          fields: [
+            {
+              key: "confidence",
+              label: "Confidence Threshold",
+              type: "slider",
+              min: 0.1,
+              max: 1,
+              step: 0.05,
+              default: 0.5
+            },
+            {
+              key: "iouThreshold",
+              label: "IoU Threshold (NMS)",
+              type: "slider",
+              min: 0.1,
+              max: 1,
+              step: 0.05,
+              default: 0.45
+            }
+          ]
+        }
+      ]
+    };
+  }
+  getClassMap() {
+    return import_types.COCO_TO_MACRO;
+  }
+  getModelCatalog() {
+    return [...ALL_DETECTION_MODELS];
+  }
+  getAvailableModels() {
+    return [];
+  }
+  getActiveLabels() {
+    return import_types.MACRO_LABELS;
+  }
+  async probe() {
+    return {
+      available: true,
+      runtime: this.engine?.runtime ?? "onnx",
+      device: this.engine?.device ?? "cpu",
+      capabilities: ["fp32"]
+    };
+  }
+};
+//# sourceMappingURL=index.js.map