circuit-json-to-gltf 0.0.71 → 0.0.72

package/dist/index.d.ts

@@ -196,6 +196,38 @@ declare const COORDINATE_TRANSFORMS: {
     readonly OBJ_Z_UP_TO_Y_UP: CoordinateTransformConfig;
 };
 
+interface CameraFitOptions {
+    /**
+     * Target-to-camera direction vector used for solved camera position.
+     */
+    direction?: readonly [number, number, number];
+    /**
+     * Vertical field of view in degrees.
+     */
+    fov?: number;
+    /**
+     * Aspect ratio (width / height) used for horizontal fit calculations.
+     */
+    aspectRatio?: number;
+    /**
+     * Focal length in millimeters. If provided with sensorHeight,
+     * it is used instead of fov.
+     */
+    focalLength?: number;
+    /**
+     * Sensor height in millimeters for focalLength->fov conversion.
+     */
+    sensorHeight?: number;
+}
+/**
+ * Calculate optimal camera position for PCB viewing based on circuit dimensions
+ */
+declare function getBestCameraPosition(circuitJson: CircuitJson): {
+    camPos: readonly [number, number, number];
+    lookAt: readonly [number, number, number];
+    fov: number;
+};
+
 declare function convertCircuitJsonToGltf(circuitJson: CircuitJson, options?: ConversionOptions): Promise<ArrayBuffer | object>;
 
 interface Point {
@@ -208,4 +240,4 @@ interface BRepShape {
     is_negative?: boolean;
 }
 
-export { type BRepShape, type BoardRenderOptions, type BoundingBox, type Box3D, COORDINATE_TRANSFORMS, type Camera3D, type CircuitTo3DOptions, type Color, type ConversionOptions, type CoordinateTransformConfig, type GLTFExportOptions, type LayerRef, type Light3D, type OBJMaterial, type OBJMesh, type Point, type Point3, type STLMesh, type Scene3D, type Size3, type Triangle, applyCoordinateTransform, clearGLBCache, clearOBJCache, clearSTLCache, convertCircuitJsonTo3D, convertCircuitJsonToGltf, convertSceneToGLTF, loadGLB, loadOBJ, loadSTL, renderBoardLayer, renderBoardTextures, transformTriangles };
+export { type BRepShape, type BoardRenderOptions, type BoundingBox, type Box3D, COORDINATE_TRANSFORMS, type Camera3D, type CameraFitOptions, type CircuitTo3DOptions, type Color, type ConversionOptions, type CoordinateTransformConfig, type GLTFExportOptions, type LayerRef, type Light3D, type OBJMaterial, type OBJMesh, type Point, type Point3, type STLMesh, type Scene3D, type Size3, type Triangle, applyCoordinateTransform, clearGLBCache, clearOBJCache, clearSTLCache, convertCircuitJsonTo3D, convertCircuitJsonToGltf, convertSceneToGLTF, getBestCameraPosition, loadGLB, loadOBJ, loadSTL, renderBoardLayer, renderBoardTextures, transformTriangles };

package/dist/index.js

@@ -446,8 +446,8 @@ var require_add2 = __commonJS({
 var require_dot = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec3/dot.js"(exports, module) {
     "use strict";
-    var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-    module.exports = dot;
+    var dot2 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+    module.exports = dot2;
   }
 });
 
@@ -455,7 +455,7 @@ var require_dot = __commonJS({
 var require_angle = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec3/angle.js"(exports, module) {
     "use strict";
-    var dot = require_dot();
+    var dot2 = require_dot();
     var angle = (a, b) => {
       const ax = a[0];
       const ay = a[1];
@@ -466,7 +466,7 @@ var require_angle = __commonJS({
       const mag1 = Math.sqrt(ax * ax + ay * ay + az * az);
       const mag2 = Math.sqrt(bx * bx + by * by + bz * bz);
       const mag = mag1 * mag2;
-      const cosine = mag && dot(a, b) / mag;
+      const cosine = mag && dot2(a, b) / mag;
       return Math.acos(Math.min(Math.max(cosine, -1), 1));
     };
     module.exports = angle;
@@ -516,7 +516,7 @@ var require_copy2 = __commonJS({
 var require_cross = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec3/cross.js"(exports, module) {
     "use strict";
-    var cross = (out, a, b) => {
+    var cross2 = (out, a, b) => {
       const ax = a[0];
       const ay = a[1];
       const az = a[2];
@@ -528,7 +528,7 @@ var require_cross = __commonJS({
       out[2] = ax * by - ay * bx;
       return out;
     };
-    module.exports = cross;
+    module.exports = cross2;
   }
 });
 
@@ -724,13 +724,13 @@ var require_orthogonal = __commonJS({
     "use strict";
     var abs = require_abs();
     var create = require_create2();
-    var cross = require_cross();
+    var cross2 = require_cross();
     var orthogonal = (out, vector) => {
       const bV = abs(create(), vector);
       const b0 = 0 + (bV[0] < bV[1] && bV[0] < bV[2]);
       const b1 = 0 + (bV[1] <= bV[0] && bV[1] < bV[2]);
       const b2 = 0 + (bV[2] <= bV[0] && bV[2] <= bV[1]);
-      return cross(out, vector, [b0, b1, b2]);
+      return cross2(out, vector, [b0, b1, b2]);
     };
     module.exports = orthogonal;
   }
@@ -1650,13 +1650,13 @@ var require_copy3 = __commonJS({
 var require_cross2 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec2/cross.js"(exports, module) {
     "use strict";
-    var cross = (out, a, b) => {
+    var cross2 = (out, a, b) => {
       out[0] = 0;
       out[1] = 0;
       out[2] = a[0] * b[1] - a[1] * b[0];
       return out;
     };
-    module.exports = cross;
+    module.exports = cross2;
   }
 });
 
@@ -1690,8 +1690,8 @@ var require_divide2 = __commonJS({
 var require_dot2 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec2/dot.js"(exports, module) {
     "use strict";
-    var dot = (a, b) => a[0] * b[0] + a[1] * b[1];
-    module.exports = dot;
+    var dot2 = (a, b) => a[0] * b[0] + a[1] * b[1];
+    module.exports = dot2;
   }
 });
 
@@ -2401,7 +2401,7 @@ var require_create5 = __commonJS({
 var require_point_line_distance = __commonJS({
   "node_modules/@jscad/modeling/src/operations/hulls/quickhull/point-line-distance.js"(exports, module) {
     "use strict";
-    var cross = require_cross();
+    var cross2 = require_cross();
     var subtract3 = require_subtract();
     var squaredLength = require_squaredLength();
     var distanceSquared = (p, a, b) => {
@@ -2410,7 +2410,7 @@ var require_point_line_distance = __commonJS({
       const cr = [];
       subtract3(ab, b, a);
       subtract3(ap, p, a);
-      const area = squaredLength(cross(cr, ap, ab));
+      const area = squaredLength(cross2(cr, ap, ab));
       const s = squaredLength(ab);
       if (s === 0) {
         throw Error("a and b are the same point");
@@ -2426,14 +2426,14 @@ var require_point_line_distance = __commonJS({
 var require_get_plane_normal = __commonJS({
   "node_modules/@jscad/modeling/src/operations/hulls/quickhull/get-plane-normal.js"(exports, module) {
     "use strict";
-    var cross = require_cross();
+    var cross2 = require_cross();
     var normalize = require_normalize();
     var subtract3 = require_subtract();
     var planeNormal = (out, point1, point2, point3) => {
       const tmp = [0, 0, 0];
       subtract3(out, point1, point2);
       subtract3(tmp, point2, point3);
-      cross(out, out, tmp);
+      cross2(out, out, tmp);
       return normalize(out, out);
     };
     module.exports = planeNormal;
@@ -2641,8 +2641,8 @@ var require_Face = __commonJS({
     "use strict";
     var add = require_add2();
     var copy = require_copy2();
-    var cross = require_cross();
-    var dot = require_dot();
+    var cross2 = require_cross();
+    var dot2 = require_dot();
     var length = require_length();
     var normalize = require_normalize();
     var scale = require_scale();
@@ -2688,7 +2688,7 @@ var require_Face = __commonJS({
         while (e2 !== e0) {
           copy(v1, v2);
           subtract3(v2, e2.head().point, e0.head().point);
-          add(this.normal, this.normal, cross(t, v1, v2));
+          add(this.normal, this.normal, cross2(t, v1, v2));
           e2 = e2.next;
           this.nVertices += 1;
         }
@@ -2714,7 +2714,7 @@ var require_Face = __commonJS({
           const maxVector = subtract3([], p2, p1);
           const maxLength = Math.sqrt(maxSquaredLength);
           scale(maxVector, maxVector, 1 / maxLength);
-          const maxProjection = dot(this.normal, maxVector);
+          const maxProjection = dot2(this.normal, maxVector);
           scale(maxVector, maxVector, -maxProjection);
           add(this.normal, this.normal, maxVector);
           normalize(this.normal, this.normal);
@@ -2736,10 +2736,10 @@ var require_Face = __commonJS({
           this.computeNormal();
         }
         this.computeCentroid();
-        this.offset = dot(this.normal, this.centroid);
+        this.offset = dot2(this.normal, this.centroid);
       }
       distanceToPlane(point) {
-        return dot(this.normal, point) - this.offset;
+        return dot2(this.normal, point) - this.offset;
       }
       /**
        * @private
@@ -2848,7 +2848,7 @@ var require_Face = __commonJS({
 var require_QuickHull = __commonJS({
   "node_modules/@jscad/modeling/src/operations/hulls/quickhull/QuickHull.js"(exports, module) {
     "use strict";
-    var dot = require_dot();
+    var dot2 = require_dot();
     var pointLineDistance = require_point_line_distance();
     var getPlaneNormal = require_get_plane_normal();
     var VertexList = require_VertexList();
@@ -3059,12 +3059,12 @@ var require_QuickHull = __commonJS({
           }
         }
         const normal = getPlaneNormal([], v0.point, v1.point, v2.point);
-        const distPO = dot(v0.point, normal);
+        const distPO = dot2(v0.point, normal);
         maxDistance = -1;
         for (i = 0; i < this.vertices.length; i += 1) {
           const vertex = this.vertices[i];
           if (vertex !== v0 && vertex !== v1 && vertex !== v2) {
-            const distance = Math.abs(dot(normal, vertex.point) - distPO);
+            const distance = Math.abs(dot2(normal, vertex.point) - distPO);
             if (distance > maxDistance) {
               maxDistance = distance;
               v3 = vertex;
@@ -3072,7 +3072,7 @@ var require_QuickHull = __commonJS({
           }
         }
         const faces = [];
-        if (dot(v3.point, normal) - distPO < 0) {
+        if (dot2(v3.point, normal) - distPO < 0) {
           faces.push(
             Face.createTriangle(v0, v1, v2),
             Face.createTriangle(v3, v1, v0),
@@ -4004,8 +4004,8 @@ var require_measureBoundingBox = __commonJS({
 var require_dot3 = __commonJS({
   "node_modules/@jscad/modeling/src/maths/vec4/dot.js"(exports, module) {
     "use strict";
-    var dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
-    module.exports = dot;
+    var dot2 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+    module.exports = dot2;
   }
 });
 
@@ -4112,10 +4112,10 @@ var require_measureSignedVolume = __commonJS({
     var measureSignedVolume = (polygon3) => {
       let signedVolume = 0;
       const vertices = polygon3.vertices;
-      const cross = vec3.create();
+      const cross2 = vec3.create();
       for (let i = 0; i < vertices.length - 2; i++) {
-        vec3.cross(cross, vertices[i + 1], vertices[i + 2]);
-        signedVolume += vec3.dot(vertices[0], cross);
+        vec3.cross(cross2, vertices[i + 1], vertices[i + 2]);
+        signedVolume += vec3.dot(vertices[0], cross2);
       }
       signedVolume /= 6;
       return signedVolume;
@@ -11871,8 +11871,8 @@ var require_expandShell = __commonJS({
         let bestzaxisorthogonality = 0;
         for (let i = 1; i < planes.length; i++) {
           const normal = planes[i];
-          const cross = vec3.cross(v1, xaxis, normal);
-          const crosslength = vec3.length(cross);
+          const cross2 = vec3.cross(v1, xaxis, normal);
+          const crosslength = vec3.length(cross2);
           if (crosslength > 0.05) {
             if (crosslength > bestzaxisorthogonality) {
               bestzaxisorthogonality = crosslength;
@@ -15264,16 +15264,16 @@ var geom3ToTriangles = (geometry, polygons) => {
       next2[1] - base[1],
       next2[2] - base[2]
     ];
-    const cross = [
+    const cross2 = [
       ab[1] * ac[2] - ab[2] * ac[1],
       ab[2] * ac[0] - ab[0] * ac[2],
       ab[0] * ac[1] - ab[1] * ac[0]
     ];
-    const length = Math.sqrt(cross[0] ** 2 + cross[1] ** 2 + cross[2] ** 2) || 1;
+    const length = Math.sqrt(cross2[0] ** 2 + cross2[1] ** 2 + cross2[2] ** 2) || 1;
     const normal = {
-      x: cross[0] / length,
-      y: cross[1] / length,
-      z: cross[2] / length
+      x: cross2[0] / length,
+      y: cross2[1] / length,
+      z: cross2[2] / length
     };
     for (let i = 1; i < poly.vertices.length - 1; i++) {
       const v1 = poly.vertices[i];
@@ -17190,6 +17190,130 @@ async function convertSceneToGLTF(scene, options = {}) {
   return result;
 }
 
+// lib/utils/camera-position.ts
+var DEFAULT_CAMERA_DIRECTION = [-0.7, 1.2, -0.8];
+function normalizeVector([x, y, z]) {
+  const length = Math.hypot(x, y, z);
+  if (length === 0) {
+    return [0, 1, 0];
+  }
+  return [x / length, y / length, z / length];
+}
+function dot([ax, ay, az], [bx, by, bz]) {
+  return ax * bx + ay * by + az * bz;
+}
+function cross([ax, ay, az], [bx, by, bz]) {
+  return [ay * bz - az * by, az * bx - ax * bz, ax * by - ay * bx];
+}
+function getVerticalFovRadians(opts) {
+  if (opts?.focalLength !== void 0 && opts.sensorHeight !== void 0 && opts.focalLength > 0 && opts.sensorHeight > 0) {
+    return 2 * Math.atan(opts.sensorHeight / (2 * opts.focalLength));
+  }
+  const fovDegrees = opts?.fov ?? 50;
+  const fovRadians = fovDegrees * Math.PI / 180;
+  if (!Number.isFinite(fovRadians) || fovRadians <= 0) {
+    return 50 * Math.PI / 180;
+  }
+  return Math.min(Math.max(fovRadians, 0.01), Math.PI - 0.01);
+}
+function getVerticalFovDegrees(opts) {
+  return getVerticalFovRadians(opts) * 180 / Math.PI;
+}
+function getRequiredDistanceForFrustum(corners, cameraDirection, right, up, tanHalfHorizontal, tanHalfVertical) {
+  let requiredDistance = 0;
+  for (const corner of corners) {
+    const u = [corner[0], corner[1], corner[2]];
+    const un = dot(u, cameraDirection);
+    const ur = Math.abs(dot(u, right));
+    const uu = Math.abs(dot(u, up));
+    const distanceForHorizontal = un + ur / tanHalfHorizontal;
+    const distanceForVertical = un + uu / tanHalfVertical;
+    requiredDistance = Math.max(
+      requiredDistance,
+      distanceForHorizontal,
+      distanceForVertical
+    );
+  }
+  return requiredDistance;
+}
+function getBestCameraPosition(circuitJson, opts) {
+  const verticalFovDegrees = getVerticalFovDegrees(opts);
+  const panel = circuitJson.find((item) => item.type === "pcb_panel");
+  const board = circuitJson.find((item) => item.type === "pcb_board");
+  const surface = panel || board;
+  if (!surface) {
+    return {
+      camPos: [30, 30, 25],
+      lookAt: [0, 0, 0],
+      fov: verticalFovDegrees
+    };
+  }
+  const { width, height, center } = surface;
+  if (!width || !height || !center) {
+    return {
+      camPos: [30, 30, 25],
+      lookAt: [0, 0, 0],
+      fov: verticalFovDegrees
+    };
+  }
+  const lookAtX = center.x;
+  const lookAtZ = center.y;
+  const cameraDirection = normalizeVector(
+    opts?.direction ?? DEFAULT_CAMERA_DIRECTION
+  );
+  const forward = [
+    -cameraDirection[0],
+    -cameraDirection[1],
+    -cameraDirection[2]
+  ];
+  const worldUp = [0, 1, 0];
+  const right = normalizeVector(cross(forward, worldUp));
+  const up = normalizeVector(cross(right, forward));
+  const verticalFov = verticalFovDegrees * Math.PI / 180;
+  const aspectRatio = opts?.aspectRatio !== void 0 && Number.isFinite(opts.aspectRatio) && opts.aspectRatio > 0 ? opts.aspectRatio : 4 / 3;
+  const tanHalfVertical = Math.tan(verticalFov / 2);
+  const tanHalfHorizontal = tanHalfVertical * aspectRatio;
+  const halfWidth = width / 2;
+  const halfHeight = height / 2;
+  const boardCorners = [
+    [halfWidth, 0, halfHeight],
+    [halfWidth, 0, -halfHeight],
+    [-halfWidth, 0, halfHeight],
+    [-halfWidth, 0, -halfHeight]
+  ];
+  const requiredDistanceAssumingVerticalFov = getRequiredDistanceForFrustum(
+    boardCorners,
+    cameraDirection,
+    right,
+    up,
+    tanHalfHorizontal,
+    tanHalfVertical
+  );
+  const tanHalfHorizontalIfFovIsHorizontal = tanHalfVertical;
+  const tanHalfVerticalIfFovIsHorizontal = tanHalfHorizontalIfFovIsHorizontal / aspectRatio;
+  const requiredDistanceAssumingHorizontalFov = getRequiredDistanceForFrustum(
+    boardCorners,
+    cameraDirection,
+    right,
+    up,
+    tanHalfHorizontalIfFovIsHorizontal,
+    tanHalfVerticalIfFovIsHorizontal
+  );
+  const requiredDistance = Math.max(
+    requiredDistanceAssumingVerticalFov,
+    requiredDistanceAssumingHorizontalFov
+  );
+  const distance = Math.max(requiredDistance, 1);
+  const camX = lookAtX + cameraDirection[0] * distance;
+  const camY = cameraDirection[1] * distance;
+  const camZ = lookAtZ + cameraDirection[2] * distance;
+  return {
+    camPos: [-camX, camY, camZ],
+    lookAt: [-lookAtX, 0, lookAtZ],
+    fov: verticalFovDegrees
+  };
+}
+
 // lib/index.ts
 async function convertCircuitJsonToGltf(circuitJson, options = {}) {
   const {
@@ -17227,6 +17351,7 @@ export {
   convertCircuitJsonTo3D,
   convertCircuitJsonToGltf,
   convertSceneToGLTF,
+  getBestCameraPosition,
   loadGLB,
   loadOBJ,
   loadSTL,

package/package.json

@@ -2,7 +2,7 @@
   "name": "circuit-json-to-gltf",
   "main": "dist/index.js",
   "type": "module",
-  "version": "0.0.71",
+  "version": "0.0.72",
   "scripts": {
     "test": "bun test tests/",
     "format": "biome format --write .",