@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-Q56TT7IL.js

@@ -0,0 +1,483 @@
+// src/compiler/COCOExporter.ts
+var DEFAULT_SHAPE_SIZES = {
+  box: [1, 1, 1],
+  cube: [1, 1, 1],
+  sphere: [1, 1, 1],
+  orb: [1, 1, 1],
+  cylinder: [1, 2, 1],
+  cone: [1, 2, 1],
+  pyramid: [1, 1, 1],
+  plane: [2, 0.01, 2],
+  ground: [10, 0.01, 10],
+  model: [1, 1, 1],
+  mesh: [1, 1, 1],
+  splat: [1, 1, 1],
+  nerf: [1, 1, 1]
+};
+var NPC_KEYPOINT_NAMES = [
+  "nose",
+  "left_eye",
+  "right_eye",
+  "left_ear",
+  "right_ear",
+  "left_shoulder",
+  "right_shoulder",
+  "left_elbow",
+  "right_elbow",
+  "left_wrist",
+  "right_wrist",
+  "left_hip",
+  "right_hip",
+  "left_knee",
+  "right_knee",
+  "left_ankle",
+  "right_ankle"
+];
+var NPC_SKELETON = [
+  [0, 1],
+  [0, 2],
+  [1, 3],
+  [2, 4],
+  // head
+  [5, 6],
+  [5, 7],
+  [7, 9],
+  [6, 8],
+  [8, 10],
+  // arms
+  [5, 11],
+  [6, 12],
+  [11, 12],
+  // torso
+  [11, 13],
+  [13, 15],
+  [12, 14],
+  [14, 16]
+  // legs
+];
+function exportCOCO(composition, options = {}) {
+  const exporter = new COCOExporterImpl(options);
+  return exporter.export(composition);
+}
+function exportCOCOString(composition, options = {}) {
+  return JSON.stringify(exportCOCO(composition, options), null, 2);
+}
+var COCOExporterImpl = class {
+  constructor(options = {}) {
+    this.categoryMap = /* @__PURE__ */ new Map();
+    this.categories = [];
+    this.nextCategoryId = 1;
+    this.nextAnnotationId = 1;
+    this.imageWidth = options.imageWidth ?? 1920;
+    this.imageHeight = options.imageHeight ?? 1080;
+    this.fov = options.fov ?? 60;
+    this.cameraPosition = options.cameraPosition ?? [0, 1.6, 5];
+    this.cameraTarget = options.cameraTarget ?? [0, 0, 0];
+    this.description = options.description ?? "HoloScript COCO Export";
+    this.contributor = options.contributor ?? "HoloScript";
+    this.filenameTemplate = options.filenameTemplate ?? "frame_{index}.png";
+    this.viewCount = options.viewCount ?? 1;
+    this.includeKeypoints = options.includeKeypoints ?? true;
+    this.categoryOverrides = options.categoryOverrides ?? {};
+  }
+  export(composition) {
+    this.categoryMap.clear();
+    this.categories = [];
+    this.nextCategoryId = 1;
+    this.nextAnnotationId = 1;
+    this.scanCategories(composition);
+    if (this.includeKeypoints && composition.npcs?.length > 0) {
+      this.ensureCategory("npc", "character");
+      const npcCat = this.categories.find((c) => c.name === "npc");
+      if (npcCat) {
+        npcCat.keypoints = NPC_KEYPOINT_NAMES;
+        npcCat.skeleton = NPC_SKELETON;
+      }
+    }
+    const images = [];
+    const annotations = [];
+    for (let viewIdx = 0; viewIdx < this.viewCount; viewIdx++) {
+      const imageId = viewIdx + 1;
+      const filename = this.filenameTemplate.replace("{index}", String(viewIdx).padStart(6, "0"));
+      images.push({
+        id: imageId,
+        width: this.imageWidth,
+        height: this.imageHeight,
+        file_name: filename,
+        date_captured: (/* @__PURE__ */ new Date()).toISOString(),
+        holoscript_meta: {
+          composition: composition.name,
+          view_index: viewIdx,
+          camera_position: this.cameraPosition,
+          camera_fov: this.fov
+        }
+      });
+      const sceneAnnotations = this.annotateComposition(composition, imageId);
+      annotations.push(...sceneAnnotations);
+    }
+    const now = /* @__PURE__ */ new Date();
+    return {
+      info: {
+        year: now.getFullYear(),
+        version: "1.0",
+        description: this.description,
+        contributor: this.contributor,
+        url: "https://holoscript.dev",
+        date_created: now.toISOString()
+      },
+      licenses: [
+        {
+          id: 1,
+          name: "HoloScript Synthetic Data License",
+          url: "https://holoscript.dev/license"
+        }
+      ],
+      images,
+      annotations,
+      categories: this.categories
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Category scanning
+  // ---------------------------------------------------------------------------
+  scanCategories(composition) {
+    for (const obj of composition.objects ?? []) {
+      this.scanObjectCategories(obj);
+    }
+    for (const group of composition.spatialGroups ?? []) {
+      this.scanGroupCategories(group);
+    }
+    for (const shape of composition.shapes ?? []) {
+      this.ensureCategory(shape.shapeType, "geometry");
+    }
+    for (const block of composition.domainBlocks ?? []) {
+      this.ensureCategory(block.keyword, block.domain);
+    }
+  }
+  scanObjectCategories(obj) {
+    const categoryName = this.inferCategory(obj);
+    const supercategory = this.inferSupercategory(obj);
+    this.ensureCategory(categoryName, supercategory);
+    for (const child of obj.children ?? []) {
+      this.scanObjectCategories(child);
+    }
+  }
+  scanGroupCategories(group) {
+    for (const obj of group.objects ?? []) {
+      this.scanObjectCategories(obj);
+    }
+    for (const child of group.groups ?? []) {
+      this.scanGroupCategories(child);
+    }
+  }
+  ensureCategory(name, supercategory) {
+    if (this.categoryOverrides[name]) {
+      name = this.categoryOverrides[name].name;
+      supercategory = this.categoryOverrides[name]?.supercategory ?? supercategory;
+    }
+    if (!this.categoryMap.has(name)) {
+      const id = this.nextCategoryId++;
+      this.categoryMap.set(name, id);
+      this.categories.push({ id, name, supercategory });
+    }
+    return this.categoryMap.get(name);
+  }
+  // ---------------------------------------------------------------------------
+  // Annotation generation
+  // ---------------------------------------------------------------------------
+  annotateComposition(composition, imageId) {
+    const annotations = [];
+    for (const obj of composition.objects ?? []) {
+      annotations.push(...this.annotateObject(obj, imageId, [0, 0, 0]));
+    }
+    for (const group of composition.spatialGroups ?? []) {
+      annotations.push(...this.annotateGroup(group, imageId, [0, 0, 0]));
+    }
+    for (const npc of composition.npcs ?? []) {
+      annotations.push(...this.annotateNPC(npc, imageId));
+    }
+    for (const shape of composition.shapes ?? []) {
+      annotations.push(...this.annotateShape(shape, imageId));
+    }
+    return annotations;
+  }
+  annotateObject(obj, imageId, parentOffset) {
+    const annotations = [];
+    const position = this.extractPosition(obj.properties, parentOffset);
+    const scale = this.extractScale(obj.properties);
+    const geometry = this.inferGeometry(obj);
+    const size = [
+      (DEFAULT_SHAPE_SIZES[geometry]?.[0] ?? 1) * scale[0],
+      (DEFAULT_SHAPE_SIZES[geometry]?.[1] ?? 1) * scale[1],
+      (DEFAULT_SHAPE_SIZES[geometry]?.[2] ?? 1) * scale[2]
+    ];
+    const bbox = this.projectBoundingBox(position, size);
+    if (bbox) {
+      const categoryName = this.inferCategory(obj);
+      const categoryId = this.categoryMap.get(categoryName) ?? 1;
+      const annotation = {
+        id: this.nextAnnotationId++,
+        image_id: imageId,
+        category_id: categoryId,
+        bbox,
+        area: bbox[2] * bbox[3],
+        segmentation: [this.bboxToPolygon(bbox)],
+        iscrowd: 0
+      };
+      if (obj.traits?.length > 0) {
+        annotation.attributes = {};
+        for (const trait of obj.traits) {
+          annotation.attributes[trait.name] = trait.config;
+        }
+      }
+      annotations.push(annotation);
+    }
+    for (const child of obj.children ?? []) {
+      annotations.push(...this.annotateObject(child, imageId, position));
+    }
+    return annotations;
+  }
+  annotateGroup(group, imageId, parentOffset) {
+    const annotations = [];
+    const groupOffset = this.extractGroupPosition(group, parentOffset);
+    for (const obj of group.objects ?? []) {
+      annotations.push(...this.annotateObject(obj, imageId, groupOffset));
+    }
+    for (const child of group.groups ?? []) {
+      annotations.push(...this.annotateGroup(child, imageId, groupOffset));
+    }
+    return annotations;
+  }
+  annotateNPC(npc, imageId) {
+    const annotations = [];
+    const position = this.extractNPCPosition(npc);
+    const size = [0.6, 1.8, 0.4];
+    const bbox = this.projectBoundingBox(position, size);
+    if (!bbox) return annotations;
+    const categoryId = this.categoryMap.get("npc") ?? 1;
+    const annotation = {
+      id: this.nextAnnotationId++,
+      image_id: imageId,
+      category_id: categoryId,
+      bbox,
+      area: bbox[2] * bbox[3],
+      segmentation: [this.bboxToPolygon(bbox)],
+      iscrowd: 0
+    };
+    if (this.includeKeypoints) {
+      const keypoints = this.generateNPCKeypoints(position, bbox);
+      annotation.keypoints = keypoints;
+      annotation.num_keypoints = NPC_KEYPOINT_NAMES.length;
+    }
+    annotations.push(annotation);
+    return annotations;
+  }
+  annotateShape(shape, imageId) {
+    const annotations = [];
+    const position = [0, 0, 0];
+    const size = DEFAULT_SHAPE_SIZES[shape.shapeType] ?? [1, 1, 1];
+    for (const prop of shape.properties) {
+      if (prop.key === "position" && Array.isArray(prop.value)) {
+        const arr = prop.value;
+        position[0] = arr[0] ?? 0;
+        position[1] = arr[1] ?? 0;
+        position[2] = arr[2] ?? 0;
+      }
+    }
+    const bbox = this.projectBoundingBox(position, size);
+    if (!bbox) return annotations;
+    const categoryId = this.categoryMap.get(shape.shapeType) ?? 1;
+    annotations.push({
+      id: this.nextAnnotationId++,
+      image_id: imageId,
+      category_id: categoryId,
+      bbox,
+      area: bbox[2] * bbox[3],
+      segmentation: [this.bboxToPolygon(bbox)],
+      iscrowd: 0
+    });
+    return annotations;
+  }
+  // ---------------------------------------------------------------------------
+  // Projection (simplified pinhole camera model)
+  // ---------------------------------------------------------------------------
+  /**
+   * Project a 3D bounding box to 2D image coordinates using a pinhole camera model.
+   * Returns [x, y, width, height] in COCO format or null if behind camera.
+   */
+  projectBoundingBox(position, size) {
+    const focalLength = this.imageWidth / 2 / Math.tan(this.fov * Math.PI / 360);
+    const cx = position[0] - this.cameraPosition[0];
+    const cy = position[1] - this.cameraPosition[1];
+    const cz = this.cameraPosition[2] - position[2];
+    if (cz <= 0.01) return null;
+    const px = cx * focalLength / cz + this.imageWidth / 2;
+    const py = -(cy * focalLength) / cz + this.imageHeight / 2;
+    const projW = size[0] * focalLength / cz;
+    const projH = size[1] * focalLength / cz;
+    const x = Math.max(0, Math.round(px - projW / 2));
+    const y = Math.max(0, Math.round(py - projH / 2));
+    const w = Math.min(this.imageWidth - x, Math.round(projW));
+    const h = Math.min(this.imageHeight - y, Math.round(projH));
+    if (w <= 0 || h <= 0) return null;
+    return [x, y, w, h];
+  }
+  /** Convert bounding box to polygon format for segmentation */
+  bboxToPolygon(bbox) {
+    const [x, y, w, h] = bbox;
+    return [x, y, x + w, y, x + w, y + h, x, y + h];
+  }
+  // ---------------------------------------------------------------------------
+  // Property extraction helpers
+  // ---------------------------------------------------------------------------
+  extractPosition(properties, parentOffset) {
+    const pos = [...parentOffset];
+    for (const prop of properties) {
+      if (prop.key === "position" && Array.isArray(prop.value)) {
+        const arr = prop.value;
+        pos[0] += arr[0] ?? 0;
+        pos[1] += arr[1] ?? 0;
+        pos[2] += arr[2] ?? 0;
+      }
+    }
+    return pos;
+  }
+  extractScale(properties) {
+    for (const prop of properties) {
+      if (prop.key === "scale") {
+        if (typeof prop.value === "number") {
+          return [prop.value, prop.value, prop.value];
+        }
+        if (Array.isArray(prop.value)) {
+          const arr = prop.value;
+          return [arr[0] ?? 1, arr[1] ?? 1, arr[2] ?? 1];
+        }
+      }
+    }
+    return [1, 1, 1];
+  }
+  extractGroupPosition(group, parentOffset) {
+    const pos = [...parentOffset];
+    for (const prop of group.properties) {
+      if (prop.key === "position" && Array.isArray(prop.value)) {
+        const arr = prop.value;
+        pos[0] += arr[0] ?? 0;
+        pos[1] += arr[1] ?? 0;
+        pos[2] += arr[2] ?? 0;
+      }
+    }
+    return pos;
+  }
+  extractNPCPosition(npc) {
+    for (const prop of npc.properties) {
+      if (prop.key === "position" && Array.isArray(prop.value)) {
+        const arr = prop.value;
+        return [arr[0] ?? 0, arr[1] ?? 0, arr[2] ?? 0];
+      }
+    }
+    return [0, 0, 0];
+  }
+  // ---------------------------------------------------------------------------
+  // Category/geometry inference
+  // ---------------------------------------------------------------------------
+  inferCategory(obj) {
+    for (const trait of obj.traits ?? []) {
+      if (this.categoryOverrides[trait.name]) {
+        return this.categoryOverrides[trait.name].name;
+      }
+    }
+    if (obj.template) return obj.template.toLowerCase();
+    const geometryTrait = obj.traits?.find(
+      (t) => ["geometry", "mesh", "model", "shape"].includes(t.name.toLowerCase())
+    );
+    if (geometryTrait) {
+      const shapeType = geometryTrait.config["type"] ?? geometryTrait.config["shape"];
+      if (typeof shapeType === "string") return shapeType;
+    }
+    return obj.name.toLowerCase().replace(/[^a-z0-9]+/g, "_");
+  }
+  inferSupercategory(obj) {
+    for (const trait of obj.traits ?? []) {
+      const name = trait.name.toLowerCase();
+      if (["interactive", "clickable", "draggable"].includes(name)) return "interactive";
+      if (["animated", "moving"].includes(name)) return "dynamic";
+      if (["physics", "rigidbody", "collider"].includes(name)) return "physics";
+      if (["light", "emissive", "glow"].includes(name)) return "lighting";
+    }
+    return "object";
+  }
+  inferGeometry(obj) {
+    for (const prop of obj.properties) {
+      if (prop.key === "geometry" || prop.key === "shape") {
+        if (typeof prop.value === "string") return prop.value;
+      }
+    }
+    const geoTrait = obj.traits?.find(
+      (t) => t.name.toLowerCase() === "geometry" || t.name.toLowerCase() === "mesh"
+    );
+    if (geoTrait) {
+      const shape = geoTrait.config["type"] ?? geoTrait.config["shape"];
+      if (typeof shape === "string") return shape;
+    }
+    return "cube";
+  }
+  // ---------------------------------------------------------------------------
+  // NPC keypoint generation
+  // ---------------------------------------------------------------------------
+  /**
+   * Generate approximate COCO-format keypoints for an NPC within its bounding box.
+   * Format: [x1, y1, v1, x2, y2, v2, ...] where v=2 means visible.
+   */
+  generateNPCKeypoints(position, bbox) {
+    const [bx, by, bw, bh] = bbox;
+    const keypointRatios = [
+      [0.5, 0.05],
+      // nose
+      [0.45, 0.04],
+      // left_eye
+      [0.55, 0.04],
+      // right_eye
+      [0.4, 0.06],
+      // left_ear
+      [0.6, 0.06],
+      // right_ear
+      [0.35, 0.22],
+      // left_shoulder
+      [0.65, 0.22],
+      // right_shoulder
+      [0.28, 0.4],
+      // left_elbow
+      [0.72, 0.4],
+      // right_elbow
+      [0.25, 0.55],
+      // left_wrist
+      [0.75, 0.55],
+      // right_wrist
+      [0.38, 0.55],
+      // left_hip
+      [0.62, 0.55],
+      // right_hip
+      [0.36, 0.75],
+      // left_knee
+      [0.64, 0.75],
+      // right_knee
+      [0.34, 0.95],
+      // left_ankle
+      [0.66, 0.95]
+      // right_ankle
+    ];
+    const keypoints = [];
+    for (const [rx, ry] of keypointRatios) {
+      const kx = Math.round(bx + bw * rx);
+      const ky = Math.round(by + bh * ry);
+      const visible = 2;
+      keypoints.push(kx, ky, visible);
+    }
+    return keypoints;
+  }
+};
+var COCOExporter_default = exportCOCO;
+
+export { COCOExporterImpl, COCOExporter_default, exportCOCO, exportCOCOString };
+//# sourceMappingURL=chunk-Q56TT7IL.js.map
+//# sourceMappingURL=chunk-Q56TT7IL.js.map