circuit-json-to-step 0.0.21 → 0.0.23

package/lib/index.ts

@@ -91,6 +91,7 @@ export async function circuitJsonToStep(
   // Get board center position (defaults to 0, 0 if not specified)
   const boardCenterX = pcbBoard?.center?.x ?? 0
   const boardCenterY = pcbBoard?.center?.y ?? 0
+  const halfBoardThickness = boardThickness / 2
 
   if (!boardWidth || !boardHeight) {
     throw new Error(
@@ -193,7 +194,9 @@ export async function circuitJsonToStep(
       repo.add(
         new VertexPoint(
           "",
-          repo.add(new CartesianPoint("", point.x, point.y, 0)),
+          repo.add(
+            new CartesianPoint("", point.x, point.y, -halfBoardThickness),
+          ),
         ),
       ),
     )
@@ -201,7 +204,9 @@ export async function circuitJsonToStep(
       repo.add(
         new VertexPoint(
           "",
-          repo.add(new CartesianPoint("", point.x, point.y, boardThickness)),
+          repo.add(
+            new CartesianPoint("", point.x, point.y, halfBoardThickness),
+          ),
         ),
       ),
     )
@@ -210,14 +215,30 @@ export async function circuitJsonToStep(
     const halfWidth = boardWidth / 2
     const halfHeight = boardHeight / 2
     const corners = [
-      [boardCenterX - halfWidth, boardCenterY - halfHeight, 0],
-      [boardCenterX + halfWidth, boardCenterY - halfHeight, 0],
-      [boardCenterX + halfWidth, boardCenterY + halfHeight, 0],
-      [boardCenterX - halfWidth, boardCenterY + halfHeight, 0],
-      [boardCenterX - halfWidth, boardCenterY - halfHeight, boardThickness],
-      [boardCenterX + halfWidth, boardCenterY - halfHeight, boardThickness],
-      [boardCenterX + halfWidth, boardCenterY + halfHeight, boardThickness],
-      [boardCenterX - halfWidth, boardCenterY + halfHeight, boardThickness],
+      [
+        boardCenterX - halfWidth,
+        boardCenterY - halfHeight,
+        -halfBoardThickness,
+      ],
+      [
+        boardCenterX + halfWidth,
+        boardCenterY - halfHeight,
+        -halfBoardThickness,
+      ],
+      [
+        boardCenterX + halfWidth,
+        boardCenterY + halfHeight,
+        -halfBoardThickness,
+      ],
+      [
+        boardCenterX - halfWidth,
+        boardCenterY + halfHeight,
+        -halfBoardThickness,
+      ],
+      [boardCenterX - halfWidth, boardCenterY - halfHeight, halfBoardThickness],
+      [boardCenterX + halfWidth, boardCenterY - halfHeight, halfBoardThickness],
+      [boardCenterX + halfWidth, boardCenterY + halfHeight, halfBoardThickness],
+      [boardCenterX - halfWidth, boardCenterY + halfHeight, halfBoardThickness],
     ]
     const vertices = corners.map(([x, y, z]) =>
       repo.add(
@@ -283,11 +304,11 @@ export async function circuitJsonToStep(
     verticalEdges.push(createEdge(bottomVertices[i]!, topVertices[i]!))
   }
 
-  const origin = repo.add(new CartesianPoint("", 0, 0, 0))
+  const origin = repo.add(new CartesianPoint("", 0, 0, -halfBoardThickness))
   const xDir = repo.add(new Direction("", 1, 0, 0))
   const zDir = repo.add(new Direction("", 0, 0, 1))
 
-  // Bottom face (z=0, normal pointing down)
+  // Bottom face (z=-boardThickness/2, normal pointing down)
   const bottomFrame = repo.add(
     new Axis2Placement3D(
       "",
@@ -314,11 +335,15 @@ export async function circuitJsonToStep(
       const holeY = typeof hole.y === "number" ? hole.y : (hole.y as any).value
       const radius = hole.hole_diameter / 2
 
-      const holeCenter = repo.add(new CartesianPoint("", holeX, holeY, 0))
+      const holeCenter = repo.add(
+        new CartesianPoint("", holeX, holeY, -halfBoardThickness),
+      )
       const holeVertex = repo.add(
         new VertexPoint(
           "",
-          repo.add(new CartesianPoint("", holeX + radius, holeY, 0)),
+          repo.add(
+            new CartesianPoint("", holeX + radius, holeY, -halfBoardThickness),
+          ),
         ),
       )
       const holePlacement = repo.add(
@@ -338,8 +363,8 @@ export async function circuitJsonToStep(
       )
       bottomHoleLoops.push(repo.add(new FaceBound("", holeLoop, true)))
     } else if (holeShape === "rotated_pill" || holeShape === "pill") {
-      // Create rotated pill-shaped hole boundary at z=0
-      const pillLoop = createPillHoleLoop(repo, hole, 0, xDir)
+      // Create rotated pill-shaped hole boundary at z=-boardThickness/2
+      const pillLoop = createPillHoleLoop(repo, hole, -halfBoardThickness, xDir)
       bottomHoleLoops.push(repo.add(new FaceBound("", pillLoop, true)))
     }
   }
@@ -356,8 +381,8 @@ export async function circuitJsonToStep(
     ),
   )
 
-  // Top face (z=boardThickness, normal pointing up)
-  const topOrigin = repo.add(new CartesianPoint("", 0, 0, boardThickness))
+  // Top face (z=boardThickness/2, normal pointing up)
+  const topOrigin = repo.add(new CartesianPoint("", 0, 0, halfBoardThickness))
   const topFrame = repo.add(new Axis2Placement3D("", topOrigin, zDir, xDir))
   const topPlane = repo.add(new Plane("", topFrame))
   const topLoop = repo.add(
@@ -378,13 +403,13 @@ export async function circuitJsonToStep(
       const radius = hole.hole_diameter / 2
 
       const holeCenter = repo.add(
-        new CartesianPoint("", holeX, holeY, boardThickness),
+        new CartesianPoint("", holeX, holeY, halfBoardThickness),
       )
       const holeVertex = repo.add(
         new VertexPoint(
           "",
           repo.add(
-            new CartesianPoint("", holeX + radius, holeY, boardThickness),
+            new CartesianPoint("", holeX + radius, holeY, halfBoardThickness),
           ),
         ),
       )
@@ -400,8 +425,8 @@ export async function circuitJsonToStep(
       )
       topHoleLoops.push(repo.add(new FaceBound("", holeLoop, true)))
     } else if (holeShape === "rotated_pill" || holeShape === "pill") {
-      // Create rotated pill-shaped hole boundary at z=boardThickness
-      const pillLoop = createPillHoleLoop(repo, hole, boardThickness, xDir)
+      // Create rotated pill-shaped hole boundary at z=boardThickness/2
+      const pillLoop = createPillHoleLoop(repo, hole, halfBoardThickness, xDir)
       topHoleLoops.push(repo.add(new FaceBound("", pillLoop, true)))
     }
   }
@@ -430,7 +455,7 @@ export async function circuitJsonToStep(
     const edgeDir = {
       x: bottomV2.x - bottomV1.x,
       y: bottomV2.y - bottomV1.y,
-      z: 0,
+      z: -halfBoardThickness,
     }
     // Normal is perpendicular (rotate 90 degrees clockwise in XY plane for outward facing)
     const normalDir = repo.add(new Direction("", edgeDir.y, -edgeDir.x, 0))
@@ -471,11 +496,15 @@ export async function circuitJsonToStep(
       const radius = hole.hole_diameter / 2
 
       // Create circular edges at bottom and top
-      const bottomHoleCenter = repo.add(new CartesianPoint("", holeX, holeY, 0))
+      const bottomHoleCenter = repo.add(
+        new CartesianPoint("", holeX, holeY, -halfBoardThickness),
+      )
       const bottomHoleVertex = repo.add(
         new VertexPoint(
           "",
-          repo.add(new CartesianPoint("", holeX + radius, holeY, 0)),
+          repo.add(
+            new CartesianPoint("", holeX + radius, holeY, -halfBoardThickness),
+          ),
         ),
       )
       const bottomHolePlacement = repo.add(
@@ -500,13 +529,13 @@ export async function circuitJsonToStep(
       )
 
       const topHoleCenter = repo.add(
-        new CartesianPoint("", holeX, holeY, boardThickness),
+        new CartesianPoint("", holeX, holeY, halfBoardThickness),
       )
       const topHoleVertex = repo.add(
         new VertexPoint(
           "",
           repo.add(
-            new CartesianPoint("", holeX + radius, holeY, boardThickness),
+            new CartesianPoint("", holeX + radius, holeY, halfBoardThickness),
           ),
         ),
       )
@@ -547,7 +576,8 @@ export async function circuitJsonToStep(
       const pillFaces = createPillCylindricalFaces(
         repo,
         hole,
-        boardThickness,
+        -halfBoardThickness,
+        halfBoardThickness,
         xDir,
         zDir,
       )

package/lib/mesh-generation.ts

@@ -1,23 +1,8 @@
 import type { CircuitJson } from "circuit-json"
-import type { Ref } from "stepts"
-import type { Triangle as GLTFTriangle } from "circuit-json-to-gltf"
-import type { Repository } from "stepts"
-import {
-  AdvancedFace,
-  Axis2Placement3D,
-  CartesianPoint,
-  ClosedShell,
-  Direction,
-  EdgeCurve,
-  EdgeLoop,
-  FaceOuterBound,
-  Line,
-  ManifoldSolidBrep,
-  OrientedEdge,
-  Plane,
-  Vector,
-  VertexPoint,
-} from "stepts"
+import type { Ref, Repository } from "stepts"
+import { ManifoldSolidBrep } from "stepts"
+import { createSceneBoxSolid } from "./scene-box-to-step"
+import type { SceneBox } from "./scene-geometry"
 
 export interface MeshGenerationOptions {
   /** Repository to add STEP entities to */
@@ -36,215 +21,6 @@ export interface MeshGenerationOptions {
   pcbComponentIdsWithStepUrl?: Set<string>
 }
 
-/**
- * Generates triangles for a box mesh
- */
-function createBoxTriangles(box: {
-  center: { x: number; y: number; z: number }
-  size: { x: number; y: number; z: number }
-  rotation?: { x: number; y: number; z: number }
-}): GLTFTriangle[] {
-  const { center, size } = box
-  const halfX = size.x / 2
-  const halfY = size.y / 2
-  const halfZ = size.z / 2
-
-  // Define 8 corners of the box
-  const corners = [
-    { x: -halfX, y: -halfY, z: -halfZ },
-    { x: halfX, y: -halfY, z: -halfZ },
-    { x: halfX, y: halfY, z: -halfZ },
-    { x: -halfX, y: halfY, z: -halfZ },
-    { x: -halfX, y: -halfY, z: halfZ },
-    { x: halfX, y: -halfY, z: halfZ },
-    { x: halfX, y: halfY, z: halfZ },
-    { x: -halfX, y: halfY, z: halfZ },
-  ].map((p) => ({ x: p.x + center.x, y: p.y + center.y, z: p.z + center.z }))
-
-  // Define triangles for each face (2 triangles per face)
-  const triangles: GLTFTriangle[] = [
-    // Bottom face (z = -halfZ)
-    {
-      vertices: [corners[0]!, corners[1]!, corners[2]!],
-      normal: { x: 0, y: 0, z: -1 },
-    },
-    {
-      vertices: [corners[0]!, corners[2]!, corners[3]!],
-      normal: { x: 0, y: 0, z: -1 },
-    },
-    // Top face (z = halfZ)
-    {
-      vertices: [corners[4]!, corners[6]!, corners[5]!],
-      normal: { x: 0, y: 0, z: 1 },
-    },
-    {
-      vertices: [corners[4]!, corners[7]!, corners[6]!],
-      normal: { x: 0, y: 0, z: 1 },
-    },
-    // Front face (y = -halfY)
-    {
-      vertices: [corners[0]!, corners[5]!, corners[1]!],
-      normal: { x: 0, y: -1, z: 0 },
-    },
-    {
-      vertices: [corners[0]!, corners[4]!, corners[5]!],
-      normal: { x: 0, y: -1, z: 0 },
-    },
-    // Back face (y = halfY)
-    {
-      vertices: [corners[2]!, corners[6]!, corners[7]!],
-      normal: { x: 0, y: 1, z: 0 },
-    },
-    {
-      vertices: [corners[2]!, corners[7]!, corners[3]!],
-      normal: { x: 0, y: 1, z: 0 },
-    },
-    // Left face (x = -halfX)
-    {
-      vertices: [corners[0]!, corners[3]!, corners[7]!],
-      normal: { x: -1, y: 0, z: 0 },
-    },
-    {
-      vertices: [corners[0]!, corners[7]!, corners[4]!],
-      normal: { x: -1, y: 0, z: 0 },
-    },
-    // Right face (x = halfX)
-    {
-      vertices: [corners[1]!, corners[6]!, corners[2]!],
-      normal: { x: 1, y: 0, z: 0 },
-    },
-    {
-      vertices: [corners[1]!, corners[5]!, corners[6]!],
-      normal: { x: 1, y: 0, z: 0 },
-    },
-  ]
-
-  return triangles
-}
-
-/**
- * Creates STEP faces from GLTF triangles
- */
-function createStepFacesFromTriangles(
-  repo: Repository,
-  triangles: GLTFTriangle[],
-): Ref<AdvancedFace>[] {
-  const faces: Ref<AdvancedFace>[] = []
-
-  for (const triangle of triangles) {
-    // Create vertices for triangle
-    const v1 = repo.add(
-      new VertexPoint(
-        "",
-        repo.add(
-          new CartesianPoint(
-            "",
-            triangle.vertices[0]!.x,
-            triangle.vertices[0]!.y,
-            triangle.vertices[0]!.z,
-          ),
-        ),
-      ),
-    )
-    const v2 = repo.add(
-      new VertexPoint(
-        "",
-        repo.add(
-          new CartesianPoint(
-            "",
-            triangle.vertices[1]!.x,
-            triangle.vertices[1]!.y,
-            triangle.vertices[1]!.z,
-          ),
-        ),
-      ),
-    )
-    const v3 = repo.add(
-      new VertexPoint(
-        "",
-        repo.add(
-          new CartesianPoint(
-            "",
-            triangle.vertices[2]!.x,
-            triangle.vertices[2]!.y,
-            triangle.vertices[2]!.z,
-          ),
-        ),
-      ),
-    )
-
-    // Create edges between vertices
-    const p1 = v1.resolve(repo).pnt.resolve(repo)
-    const p2 = v2.resolve(repo).pnt.resolve(repo)
-
-    const createEdge = (
-      vStart: Ref<VertexPoint>,
-      vEnd: Ref<VertexPoint>,
-    ): Ref<EdgeCurve> => {
-      const pStart = vStart.resolve(repo).pnt.resolve(repo)
-      const pEnd = vEnd.resolve(repo).pnt.resolve(repo)
-      const dir = repo.add(
-        new Direction(
-          "",
-          pEnd.x - pStart.x,
-          pEnd.y - pStart.y,
-          pEnd.z - pStart.z,
-        ),
-      )
-      const vec = repo.add(new Vector("", dir, 1))
-      const line = repo.add(new Line("", vStart.resolve(repo).pnt, vec))
-      return repo.add(new EdgeCurve("", vStart, vEnd, line, true))
-    }
-
-    const edge1 = createEdge(v1, v2)
-    const edge2 = createEdge(v2, v3)
-    const edge3 = createEdge(v3, v1)
-
-    // Create edge loop for triangle
-    const edgeLoop = repo.add(
-      new EdgeLoop("", [
-        repo.add(new OrientedEdge("", edge1, true)),
-        repo.add(new OrientedEdge("", edge2, true)),
-        repo.add(new OrientedEdge("", edge3, true)),
-      ]),
-    )
-
-    // Create planar surface using triangle normal
-    const normalDir = repo.add(
-      new Direction(
-        "",
-        triangle.normal.x,
-        triangle.normal.y,
-        triangle.normal.z,
-      ),
-    )
-
-    // Use first vertex as origin, calculate reference direction from first edge
-    const refX = p2.x - p1.x
-    const refY = p2.y - p1.y
-    const refZ = p2.z - p1.z
-    const refDir = repo.add(new Direction("", refX, refY, refZ))
-
-    const placement = repo.add(
-      new Axis2Placement3D("", v1.resolve(repo).pnt, normalDir, refDir),
-    )
-    const plane = repo.add(new Plane("", placement))
-
-    // Create face
-    const face = repo.add(
-      new AdvancedFace(
-        "",
-        [repo.add(new FaceOuterBound("", edgeLoop, true))],
-        plane,
-        true,
-      ),
-    )
-    faces.push(face)
-  }
-
-  return faces
-}
-
 /**
  * Generates component meshes from circuit JSON and converts them to STEP solids
  *
@@ -264,46 +40,48 @@ export async function generateComponentMeshes(
     excludePcbComponentIds,
     pcbComponentIdsWithStepUrl,
   } = options
+
   const solids: Ref<ManifoldSolidBrep>[] = []
+
   try {
-    // Filter circuit JSON and optionally remove model URLs
     const filteredCircuitJson = circuitJson
-      .filter((e) => {
-        if (e.type === "pcb_board") return false
+      .filter((element) => {
+        if (element.type === "pcb_board") return false
+
         if (
-          e.type === "cad_component" &&
-          e.cad_component_id &&
-          excludeCadComponentIds?.has(e.cad_component_id)
+          element.type === "cad_component" &&
+          element.cad_component_id &&
+          excludeCadComponentIds?.has(element.cad_component_id)
         ) {
           return false
         }
+
         if (
-          e.type === "pcb_component" &&
-          e.pcb_component_id &&
-          excludePcbComponentIds?.has(e.pcb_component_id)
+          element.type === "pcb_component" &&
+          element.pcb_component_id &&
+          excludePcbComponentIds?.has(element.pcb_component_id)
         ) {
           return false
         }
-        // Skip cad_components that have model_step_url
-        // (they should be handled by mergeExternalStepModels, not mesh generation)
-        if (e.type === "cad_component" && e.model_step_url) {
+
+        if (element.type === "cad_component" && element.model_step_url) {
           return false
         }
-        // Skip cad_components whose pcb_component_id is covered by another cad_component with STEP URL
+
         if (
-          e.type === "cad_component" &&
-          e.pcb_component_id &&
-          pcbComponentIdsWithStepUrl?.has(e.pcb_component_id)
+          element.type === "cad_component" &&
+          element.pcb_component_id &&
+          pcbComponentIdsWithStepUrl?.has(element.pcb_component_id)
         ) {
           return false
         }
+
         return true
       })
-      .map((e) => {
-        if (!includeExternalMeshes && e.type === "cad_component") {
-          // Remove model_*_url fields to avoid hanging on external model fetches
+      .map((element) => {
+        if (!includeExternalMeshes && element.type === "cad_component") {
           return {
-            ...e,
+            ...element,
             model_3mf_url: undefined,
             model_obj_url: undefined,
             model_stl_url: undefined,
@@ -311,66 +89,25 @@ export async function generateComponentMeshes(
             model_gltf_url: undefined,
           }
         }
-        return e
+
+        return element
       })
 
-    // Dynamically import circuit-json-to-gltf to avoid bundling native dependencies
-    // Use a variable to prevent the bundler from statically analyzing the import
     const gltfModule = "circuit-json-to-gltf"
     const { convertCircuitJsonTo3D } = await import(
       /* @vite-ignore */ gltfModule
     )
 
-    // Convert circuit JSON to 3D scene
     const scene3d = await convertCircuitJsonTo3D(filteredCircuitJson, {
       boardThickness,
       renderBoardTextures: false,
     })
 
-    // Extract or generate triangles from component boxes
-    const allTriangles: GLTFTriangle[] = []
-    for (const box of scene3d.boxes) {
-      if (box.mesh && "triangles" in box.mesh) {
-        allTriangles.push(...box.mesh.triangles)
-      } else {
-        // Generate simple box mesh for this component
-        const boxTriangles = createBoxTriangles(box)
-        allTriangles.push(...boxTriangles)
-      }
-    }
-
-    // Create STEP faces from triangles if we have any
-    if (allTriangles.length > 0) {
-      // Transform triangles from GLTF XZ plane (Y=up) to STEP XY plane (Z=up)
-      const transformedTriangles = allTriangles.map((tri) => ({
-        vertices: tri.vertices.map((v) => ({
-          x: v.x,
-          y: v.z, // GLTF Z becomes STEP Y
-          z: v.y, // GLTF Y becomes STEP Z
-        })),
-        normal: {
-          x: tri.normal.x,
-          y: tri.normal.z, // GLTF Z becomes STEP Y
-          z: tri.normal.y, // GLTF Y becomes STEP Z
-        },
-      }))
-      const componentFaces = createStepFacesFromTriangles(
-        repo,
-        transformedTriangles as any,
-      )
-
-      // Create closed shell and solid for components
-      const componentShell = repo.add(
-        new ClosedShell("", componentFaces as any),
-      )
-      const componentSolid = repo.add(
-        new ManifoldSolidBrep("Components", componentShell),
-      )
-      solids.push(componentSolid)
+    for (const box of scene3d.boxes as SceneBox[]) {
+      solids.push(createSceneBoxSolid(repo, box))
     }
   } catch (error) {
     console.warn("Failed to generate component mesh:", error)
-    // Continue without components if generation fails
   }
 
   return solids