circuit-json-to-step 0.0.1

package/lib/mesh-generation.ts

@@ -0,0 +1,333 @@
+import type { CircuitJson } from "circuit-json"
+import type { Triangle as GLTFTriangle } from "circuit-json-to-gltf"
+import { convertCircuitJsonTo3D } from "circuit-json-to-gltf"
+import type { Ref } from "stepts"
+import type { Repository } from "stepts"
+import {
+  AdvancedFace,
+  Axis2Placement3D,
+  CartesianPoint,
+  ClosedShell,
+  Direction,
+  EdgeCurve,
+  EdgeLoop,
+  FaceOuterBound,
+  Line,
+  ManifoldSolidBrep,
+  OrientedEdge,
+  Plane,
+  Vector,
+  VertexPoint,
+} from "stepts"
+
+export interface MeshGenerationOptions {
+  /** Repository to add STEP entities to */
+  repo: Repository
+  /** Circuit JSON elements to convert */
+  circuitJson: CircuitJson
+  /** Board thickness in mm */
+  boardThickness: number
+  /** Include external model meshes from model_*_url fields (default: false) */
+  includeExternalMeshes?: boolean
+}
+
+/**
+ * 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
+ *
+ * By default, model_*_url fields are filtered out to prevent hanging on external
+ * model fetches during conversion. Set includeExternalMeshes to true to allow
+ * external model fetching.
+ */
+export async function generateComponentMeshes(
+  options: MeshGenerationOptions,
+): Promise<Ref<ManifoldSolidBrep>[]> {
+  const {
+    repo,
+    circuitJson,
+    boardThickness,
+    includeExternalMeshes = false,
+  } = options
+  const solids: Ref<ManifoldSolidBrep>[] = []
+
+  try {
+    // Filter circuit JSON and optionally remove model URLs
+    const filteredCircuitJson = circuitJson
+      .filter((e) => e.type !== "pcb_board")
+      .map((e) => {
+        if (!includeExternalMeshes && e.type === "cad_component") {
+          // Remove model_*_url fields to avoid hanging on external model fetches
+          return {
+            ...e,
+            model_3mf_url: undefined,
+            model_obj_url: undefined,
+            model_stl_url: undefined,
+            model_glb_url: undefined,
+            model_gltf_url: undefined,
+          }
+        }
+        return e
+      })
+
+    // 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)
+    }
+  } catch (error) {
+    console.warn("Failed to generate component mesh:", error)
+    // Continue without components if generation fails
+  }
+
+  return solids
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "circuit-json-to-step",
+  "main": "dist/index.js",
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "pull-reference": "git clone https://github.com/tscircuit/circuit-json.git && find circuit-json/tests -name '*.test.ts' -exec bash -c 'mv \"$0\" \"${0%.test.ts}.ts\"' {} \\; && git clone https://github.com/tscircuit/stepts.git && find stepts/tests -name '*.test.ts' -exec bash -c 'mv \"$0\" \"${0%.test.ts}.ts\"' {} \\;",
+    "build": "tsup-node ./lib/index.ts --format esm --dts",
+    "format": "biome format --write .",
+    "format:check": "biome format ."
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "circuit-json": "^0.0.272",
+    "occt-import-js": "^0.0.23",
+    "stepts": "^0.0.1",
+    "tsup": "^8.5.0"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@tscircuit/circuit-json-util": "^0.0.72",
+    "circuit-json-to-connectivity-map": "^0.0.22",
+    "circuit-json-to-gltf": "^0.0.19",
+    "circuit-to-svg": "^0.0.226",
+    "schematic-symbols": "^0.0.202"
+  }
+}

package/test/basics/basics01/basics01.json

@@ -0,0 +1,40 @@
+[
+  {
+    "type": "pcb_board",
+    "pcb_board_id": "pcb_board_1",
+    "width": 20,
+    "height": 15,
+    "thickness": 1.6,
+    "center": { "x": 10, "y": 7.5 },
+    "outline": [
+      { "x": 0, "y": 0 },
+      { "x": 20, "y": 0 },
+      { "x": 20, "y": 15 },
+      { "x": 0, "y": 15 }
+    ]
+  },
+  {
+    "type": "pcb_hole",
+    "pcb_hole_id": "pcb_hole_1",
+    "hole_shape": "circle",
+    "hole_diameter": 1.0,
+    "x": 5,
+    "y": 5
+  },
+  {
+    "type": "pcb_hole",
+    "pcb_hole_id": "pcb_hole_2",
+    "hole_shape": "circle",
+    "hole_diameter": 1.5,
+    "x": 15,
+    "y": 5
+  },
+  {
+    "type": "pcb_hole",
+    "pcb_hole_id": "pcb_hole_3",
+    "hole_shape": "circle",
+    "hole_diameter": 2.0,
+    "x": 10,
+    "y": 10
+  }
+]

package/test/basics/basics01/basics01.test.ts

@@ -0,0 +1,54 @@
+import { writeFileSync } from "node:fs"
+import { test, expect } from "bun:test"
+import { circuitJsonToStep } from "../../../lib/index"
+import { importStepWithOcct } from "../../utils/occt/importer"
+import circuitJson from "./basics01.json"
+
+test("basics01: convert circuit json with circular holes to STEP", async () => {
+  const stepText = await circuitJsonToStep(circuitJson as any, {
+    boardWidth: 20,
+    boardHeight: 15,
+    boardThickness: 1.6,
+    productName: "TestPCB",
+  })
+
+  // Verify STEP format
+  expect(stepText).toContain("ISO-10303-21")
+  expect(stepText).toContain("END-ISO-10303-21")
+
+  // Verify product structure
+  expect(stepText).toContain("TestPCB")
+  expect(stepText).toContain("MANIFOLD_SOLID_BREP")
+
+  // Verify holes are created (should have CIRCLE and CYLINDRICAL_SURFACE entities)
+  expect(stepText).toContain("CIRCLE")
+  expect(stepText).toContain("CYLINDRICAL_SURFACE")
+
+  // Count CIRCLE occurrences - should have 12 (3 holes × 4 circles each: 2 for top/bottom faces, 2 for cylindrical surface)
+  const circleCount = (stepText.match(/CIRCLE/g) || []).length
+  expect(circleCount).toBe(12)
+
+  // Count CYLINDRICAL_SURFACE occurrences - should have 3 (one per hole)
+  const cylinderCount = (stepText.match(/CYLINDRICAL_SURFACE/g) || []).length
+  expect(cylinderCount).toBe(3)
+
+  // Write STEP file to debug-output
+  const outputPath = "debug-output/basics01.step"
+  writeFileSync(outputPath, stepText)
+
+  console.log("✓ STEP file generated successfully")
+  console.log(`  - Circles created: ${circleCount}`)
+  console.log(`  - STEP text length: ${stepText.length} bytes`)
+  console.log(`  - Output: ${outputPath}`)
+
+  // Validate STEP file can be imported with occt-import-js
+  const occtResult = await importStepWithOcct(stepText)
+  expect(occtResult.success).toBe(true)
+  expect(occtResult.meshes.length).toBeGreaterThan(0)
+
+  const [firstMesh] = occtResult.meshes
+  expect(firstMesh.attributes.position.array.length).toBeGreaterThan(0)
+  expect(firstMesh.index.array.length).toBeGreaterThan(0)
+
+  console.log("✓ STEP file successfully validated with occt-import-js")
+}, 20000)

package/test/basics/basics02/basics02.json

@@ -0,0 +1,19 @@
+[
+  {
+    "type": "pcb_board",
+    "pcb_board_id": "pcb_board_1",
+    "width": 20,
+    "height": 15,
+    "thickness": 1.6,
+    "center": { "x": 10, "y": 7.5 },
+    "outline": [
+      { "x": 2, "y": 3 },
+      { "x": 18, "y": 3 },
+      { "x": 18, "y": 7 },
+      { "x": 20, "y": 7 },
+      { "x": 10, "y": 15 },
+      { "x": 0, "y": 7 },
+      { "x": 2, "y": 7 }
+    ]
+  }
+]

package/test/basics/basics02/basics02.test.ts

@@ -0,0 +1,38 @@
+import { writeFileSync } from "node:fs"
+import { test, expect } from "bun:test"
+import { circuitJsonToStep } from "../../../lib/index"
+import { importStepWithOcct } from "../../utils/occt/importer"
+import circuitJson from "./basics02.json"
+
+test("basics02: convert pcb_board with outline only to STEP", async () => {
+  const stepText = await circuitJsonToStep(circuitJson as any, {
+    productName: "TestPCB_Outline",
+  })
+
+  // Verify STEP format
+  expect(stepText).toContain("ISO-10303-21")
+  expect(stepText).toContain("END-ISO-10303-21")
+
+  // Verify product structure
+  expect(stepText).toContain("TestPCB_Outline")
+  expect(stepText).toContain("MANIFOLD_SOLID_BREP")
+
+  // Write STEP file to debug-output
+  const outputPath = "debug-output/basics02.step"
+  writeFileSync(outputPath, stepText)
+
+  console.log("✓ STEP file generated successfully")
+  console.log(`  - STEP text length: ${stepText.length} bytes`)
+  console.log(`  - Output: ${outputPath}`)
+
+  // Validate STEP file can be imported with occt-import-js
+  const occtResult = await importStepWithOcct(stepText)
+  expect(occtResult.success).toBe(true)
+  expect(occtResult.meshes.length).toBeGreaterThan(0)
+
+  const [firstMesh] = occtResult.meshes
+  expect(firstMesh.attributes.position.array.length).toBeGreaterThan(0)
+  expect(firstMesh.index.array.length).toBeGreaterThan(0)
+
+  console.log("✓ STEP file successfully validated with occt-import-js")
+}, 20000)

package/test/basics/basics03/basics03.json

@@ -0,0 +1,49 @@
+[
+  {
+    "type": "pcb_board",
+    "pcb_board_id": "pcb_board_1",
+    "width": 20,
+    "height": 15,
+    "thickness": 1.6,
+    "center": { "x": 10, "y": 7.5 },
+    "outline": [
+      { "x": 2, "y": 3 },
+      { "x": 18, "y": 3 },
+      { "x": 18, "y": 7 },
+      { "x": 20, "y": 7 },
+      { "x": 10, "y": 15 },
+      { "x": 0, "y": 7 },
+      { "x": 2, "y": 7 }
+    ]
+  },
+  {
+    "type": "pcb_plated_hole",
+    "pcb_plated_hole_id": "pcb_plated_hole_1",
+    "shape": "circle",
+    "outer_diameter": 2.0,
+    "hole_diameter": 1.0,
+    "x": 5,
+    "y": 5,
+    "layers": ["top", "bottom"]
+  },
+  {
+    "type": "pcb_plated_hole",
+    "pcb_plated_hole_id": "pcb_plated_hole_2",
+    "shape": "circle",
+    "outer_diameter": 2.5,
+    "hole_diameter": 1.5,
+    "x": 15,
+    "y": 5,
+    "layers": ["top", "bottom"]
+  },
+  {
+    "type": "pcb_plated_hole",
+    "pcb_plated_hole_id": "pcb_plated_hole_3",
+    "shape": "circle",
+    "outer_diameter": 3.0,
+    "hole_diameter": 2.0,
+    "x": 10,
+    "y": 10,
+    "layers": ["top", "bottom"]
+  }
+]

package/test/basics/basics03/basics03.test.ts

@@ -0,0 +1,38 @@
+import { expect, test } from "bun:test"
+import { writeFileSync } from "node:fs"
+import { circuitJsonToStep } from "../../../lib/index"
+import { importStepWithOcct } from "../../utils/occt/importer"
+import circuitJson from "./basics03.json"
+
+test("basics03: convert pcb_board with arrow outline and pcb_plated_holes to STEP", async () => {
+  const stepText = await circuitJsonToStep(circuitJson as any, {
+    productName: "TestPCB_ArrowWithPlatedHoles",
+  })
+
+  // Verify STEP format
+  expect(stepText).toContain("ISO-10303-21")
+  expect(stepText).toContain("END-ISO-10303-21")
+
+  // Verify product structure
+  expect(stepText).toContain("TestPCB_ArrowWithPlatedHoles")
+  expect(stepText).toContain("MANIFOLD_SOLID_BREP")
+
+  // Write STEP file to debug-output
+  const outputPath = "debug-output/basics03.step"
+  writeFileSync(outputPath, stepText)
+
+  console.log("✓ STEP file generated successfully")
+  console.log(`  - STEP text length: ${stepText.length} bytes`)
+  console.log(`  - Output: ${outputPath}`)
+
+  // Validate STEP file can be imported with occt-import-js
+  const occtResult = await importStepWithOcct(stepText)
+  expect(occtResult.success).toBe(true)
+  expect(occtResult.meshes.length).toBeGreaterThan(0)
+
+  const [firstMesh] = occtResult.meshes
+  expect(firstMesh.attributes.position.array.length).toBeGreaterThan(0)
+  expect(firstMesh.index.array.length).toBeGreaterThan(0)
+
+  console.log("✓ STEP file successfully validated with occt-import-js")
+}, 20000)

package/test/basics/basics04/basics04.json

@@ -0,0 +1,52 @@
+[
+  {
+    "type": "pcb_board",
+    "pcb_board_id": "pcb_board_1",
+    "width": 30,
+    "height": 20,
+    "thickness": 1.6,
+    "center": { "x": 15, "y": 10 }
+  },
+  {
+    "type": "pcb_hole",
+    "pcb_hole_id": "pcb_hole_1",
+    "hole_shape": "circle",
+    "hole_diameter": 1.0,
+    "x": 5,
+    "y": 5
+  },
+  {
+    "type": "source_component",
+    "source_component_id": "source_component_1",
+    "name": "R1",
+    "supplier_part_numbers": {},
+    "ftype": "simple_resistor"
+  },
+  {
+    "type": "pcb_component",
+    "pcb_component_id": "pcb_component_1",
+    "source_component_id": "source_component_1",
+    "center": { "x": 15, "y": 10 },
+    "width": 3,
+    "height": 1.5,
+    "layer": "top",
+    "rotation": 0
+  },
+  {
+    "type": "source_component",
+    "source_component_id": "source_component_2",
+    "name": "C1",
+    "supplier_part_numbers": {},
+    "ftype": "simple_capacitor"
+  },
+  {
+    "type": "pcb_component",
+    "pcb_component_id": "pcb_component_2",
+    "source_component_id": "source_component_2",
+    "center": { "x": 20, "y": 10 },
+    "width": 2,
+    "height": 1.25,
+    "layer": "top",
+    "rotation": 90
+  }
+]