@tscircuit/core 0.0.2326 → 0.0.2327

package/dist/index.js

@@ -159602,7 +159602,7 @@ var RoutingPhasePreparationError = class extends Error {
 var package_default = {
   name: "@tscircuit/core",
   type: "module",
-  version: "0.0.2325",
+  version: "0.0.2326",
   types: "dist/index.d.ts",
   main: "dist/index.js",
   module: "dist/index.js",
@@ -172043,7 +172043,11 @@ import {
 // lib/components/primitive-components/CopperPour/utils/mark-trace-segments-inside-copper-pour.ts
 var EPSILON30 = 1e-9;
 var isWireRoutePoint = (routePoint) => routePoint.route_type === "wire";
+var getWirePointKey = (point12) => `${point12.layer}:${point12.x}:${point12.y}`;
 var isPointOnSegment4 = (p2, a2, b2) => {
+  if (Math.hypot(b2.x - a2.x, b2.y - a2.y) <= EPSILON30) {
+    return Math.hypot(p2.x - a2.x, p2.y - a2.y) <= EPSILON30;
+  }
   const cross5 = (p2.y - a2.y) * (b2.x - a2.x) - (p2.x - a2.x) * (b2.y - a2.y);
   if (Math.abs(cross5) > EPSILON30) return false;
   const dot2 = (p2.x - a2.x) * (b2.x - a2.x) + (p2.y - a2.y) * (b2.y - a2.y);
@@ -172076,16 +172080,7 @@ var isPointInRectPour = (p2, pour) => {
   return Math.abs(localX) <= width / 2 + EPSILON30 && Math.abs(localY) <= height / 2 + EPSILON30;
 };
 var isPointInBrepPour = (p2, pour) => {
-  const outerRing = pour.brep_shape.outer_ring.vertices.map((v2) => ({
-    x: v2.x,
-    y: v2.y
-  }));
-  if (!isPointInRing2(p2, outerRing)) return false;
-  for (const innerRing of pour.brep_shape.inner_rings) {
-    const points = innerRing.vertices.map((v2) => ({ x: v2.x, y: v2.y }));
-    if (isPointInRing2(p2, points)) return false;
-  }
-  return true;
+  return isPointInRing2(p2, pour.brep_shape.outer_ring.vertices) && !pour.brep_shape.inner_rings.some((ring2) => isPointInRing2(p2, ring2.vertices));
 };
 var isPointInCopperPour = (point12, pour) => {
   if (pour.shape === "rect") {
@@ -172108,55 +172103,80 @@ var isSegmentFullyInsideCopperPour = (start, end, pour) => {
   const dy2 = end.y - start.y;
   const length9 = Math.hypot(dx2, dy2);
   if (length9 <= EPSILON30) return false;
-  const samples = [0, 0.25, 0.5, 0.75, 1];
-  return samples.every(
-    (t48) => isPointInCopperPour(
-      {
-        x: start.x + dx2 * t48,
-        y: start.y + dy2 * t48
-      },
-      pour
-    )
+  if (!isPointInCopperPour(start, pour) || !isPointInCopperPour(end, pour)) {
+    return false;
+  }
+  if (pour.shape === "rect") return true;
+  if (pour.shape !== "brep") return false;
+  for (const ring2 of [
+    pour.brep_shape.outer_ring,
+    ...pour.brep_shape.inner_rings
+  ]) {
+    const vertices = ring2.vertices;
+    for (let edgeIndex = 0; edgeIndex < vertices.length; edgeIndex++) {
+      if (doesTraceSegmentTouchPourBoundaryEdge(
+        start,
+        end,
+        vertices[edgeIndex],
+        vertices[(edgeIndex + 1) % vertices.length]
+      ))
+        return false;
+    }
+  }
+  return true;
+};
+var doesTraceSegmentTouchPourBoundaryEdge = (traceStart, traceEnd, boundaryStart, boundaryEnd) => {
+  if (isPointOnSegment4(traceStart, boundaryStart, boundaryEnd) || isPointOnSegment4(traceEnd, boundaryStart, boundaryEnd) || isPointOnSegment4(boundaryStart, traceStart, traceEnd) || isPointOnSegment4(boundaryEnd, traceStart, traceEnd))
+    return true;
+  const side = (start, end, point12) => (end.x - start.x) * (point12.y - start.y) - (end.y - start.y) * (point12.x - start.x);
+  const oppositeSides = (first, second) => first > EPSILON30 && second < -EPSILON30 || first < -EPSILON30 && second > EPSILON30;
+  return oppositeSides(
+    side(traceStart, traceEnd, boundaryStart),
+    side(traceStart, traceEnd, boundaryEnd)
+  ) && oppositeSides(
+    side(boundaryStart, boundaryEnd, traceStart),
+    side(boundaryStart, boundaryEnd, traceEnd)
   );
 };
 var markTraceSegmentsInsideCopperPour = ({
   db: db2,
   copperPour
 }) => {
-  if (!copperPour.source_net_id) return;
+  const sourceNetId = copperPour.source_net_id;
+  if (!sourceNetId) return;
   const sourceTraceById = new Map(
     db2.source_trace.list().map((sourceTrace) => [sourceTrace.source_trace_id, sourceTrace])
   );
-  for (const trace of db2.pcb_trace.list()) {
-    if (!isTraceConnectedToSourceNet(
-      trace,
-      copperPour.source_net_id,
-      sourceTraceById
-    )) {
-      continue;
+  const traceCoverage = db2.pcb_trace.list().filter(
+    (trace) => isTraceConnectedToSourceNet(trace, sourceNetId, sourceTraceById)
+  ).map((trace) => ({
+    trace,
+    coveredSegments: trace.route.slice(0, -1).map((from, segmentIndex) => {
+      const to = trace.route[segmentIndex + 1];
+      return isWireRoutePoint(from) && isWireRoutePoint(to) && from.layer === copperPour.layer && to.layer === copperPour.layer && isSegmentFullyInsideCopperPour(from, to, copperPour);
+    })
+  }));
+  const exposedPoints = /* @__PURE__ */ new Set();
+  for (const { trace, coveredSegments } of traceCoverage) {
+    for (const [routeIndex, point12] of trace.route.entries()) {
+      const coveredBefore = routeIndex === 0 || coveredSegments[routeIndex - 1];
+      const coveredAfter = routeIndex === trace.route.length - 1 || coveredSegments[routeIndex];
+      if (isWireRoutePoint(point12) && (!coveredBefore || !coveredAfter)) {
+        exposedPoints.add(getWirePointKey(point12));
+      }
     }
+  }
+  for (const { trace, coveredSegments } of traceCoverage) {
     let routeChanged = false;
-    const nextRoute = trace.route.map((routePoint) => ({ ...routePoint }));
-    for (let i2 = 0; i2 < nextRoute.length - 1; i2++) {
-      const fromRoutePoint = nextRoute[i2];
-      const toRoutePoint = nextRoute[i2 + 1];
-      if (!fromRoutePoint || !toRoutePoint) continue;
-      if (!isWireRoutePoint(fromRoutePoint) || !isWireRoutePoint(toRoutePoint))
-        continue;
-      if (fromRoutePoint.layer !== copperPour.layer || toRoutePoint.layer !== copperPour.layer)
-        continue;
-      if (isSegmentFullyInsideCopperPour(
-        { x: fromRoutePoint.x, y: fromRoutePoint.y },
-        { x: toRoutePoint.x, y: toRoutePoint.y },
-        copperPour
-      )) {
-        fromRoutePoint.is_inside_copper_pour = true;
-        fromRoutePoint.copper_pour_id = copperPour.pcb_copper_pour_id;
-        toRoutePoint.is_inside_copper_pour = true;
-        toRoutePoint.copper_pour_id = copperPour.pcb_copper_pour_id;
+    const nextRoute = trace.route.map((routePoint) => {
+      const point12 = { ...routePoint };
+      if (isWireRoutePoint(point12) && coveredSegments.length > 0 && !exposedPoints.has(getWirePointKey(point12))) {
+        point12.is_inside_copper_pour = true;
+        point12.copper_pour_id = copperPour.pcb_copper_pour_id;
         routeChanged = true;
       }
-    }
+      return point12;
+    });
     if (routeChanged) {
       db2.pcb_trace.update(trace.pcb_trace_id, { route: nextRoute });
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tscircuit/core",
   "type": "module",
-  "version": "0.0.2326",
+  "version": "0.0.2327",
   "types": "dist/index.d.ts",
   "main": "dist/index.js",
   "module": "dist/index.js",