@code3d/core 0.0.1-alpha.0

package/src/library/sketch-face.ts

@@ -0,0 +1,89 @@
+import {
+  getOC,
+  makeCircle,
+  makeLine,
+  makeThreePointArc,
+  type Edge,
+  type Face,
+  type Wire,
+} from 'replicad';
+import {castOwnedShape} from './kernel-shapes.js';
+import {sketchCurvePosition, type SketchCurve} from './sketch-curves.js';
+import type {SketchPosition} from './sketch.js';
+import type {SketchRegion} from './sketch-regions.js';
+
+/** A right-handed horizontal sketch plane: (x, y) -> (x, 0, -y), normal +Y. */
+type KernelPoint = [number, number, number];
+const position = (p: SketchPosition): KernelPoint => [p[0], 0, -p[1]];
+
+function boundaryEdge(curve: SketchCurve): Edge {
+  if (curve.kind === 'line')
+    return makeLine(position(curve.points[0]), position(curve.points[1]));
+  if (curve.kind === 'circle' || Math.abs(curve.sweep) === 2 * Math.PI)
+    return makeCircle(curve.radius, position(curve.center), [
+      0,
+      curve.kind === 'circle' || curve.sweep > 0 ? 1 : -1,
+      0,
+    ]);
+  return makeThreePointArc(
+    ...([0, 0.5, 1].map(t => position(sketchCurvePosition(curve, t))) as [
+      KernelPoint,
+      KernelPoint,
+      KernelPoint,
+    ]),
+  );
+}
+
+function boundaryWire(curves: readonly SketchCurve[]): Wire {
+  const oc = getOC();
+  const builder = new oc.BRepBuilderAPI_MakeWire();
+  const edges: Edge[] = [];
+  try {
+    for (const curve of curves) {
+      const edge = boundaryEdge(curve);
+      edges.push(edge);
+      builder.Add(edge.wrapped);
+    }
+    if (!builder.IsDone())
+      throw new Error('Could not connect the sketch contour into a wire.');
+    return castOwnedShape(builder.Wire()) as Wire;
+  } finally {
+    builder.delete();
+    edges.forEach(edge => edge.delete());
+  }
+}
+
+export function sketchRegionFace(region: SketchRegion): Face {
+  const oc = getOC();
+  const wires: Wire[] = [];
+  try {
+    for (const curves of [region.outer, ...region.holes])
+      wires.push(boundaryWire(curves));
+    const builder = new oc.BRepBuilderAPI_MakeFace(wires[0].wrapped, true);
+    try {
+      for (const hole of wires.slice(1)) builder.Add(hole.wrapped);
+      if (!builder.IsDone())
+        throw new Error('Could not create a planar sketch face.');
+      const face = castOwnedShape(builder.Face()) as Face;
+      try {
+        const analyzer = new oc.BRepCheck_Analyzer(face.wrapped, true, false);
+        try {
+          if (!analyzer.IsValid())
+            throw new Error(
+              'The sketch contours do not form a valid planar face.',
+            );
+        } finally {
+          analyzer.delete();
+        }
+        return face;
+      } catch (error) {
+        face.delete();
+        throw error;
+      }
+    } finally {
+      builder.delete();
+    }
+  } finally {
+    wires.forEach(wire => wire.delete());
+  }
+}

package/src/library/sketch-incidence.ts

@@ -0,0 +1,204 @@
+import type {SketchPosition} from './sketch.js';
+import type {SketchSolveProblem, SketchSolveResult} from './sketch-solver.js';
+import {
+  sketchCurveTolerance,
+  sketchArcGeometry,
+  sketchCurveClosestParameter,
+  sketchCurvePosition,
+  type SketchCurve,
+} from './sketch-curves.js';
+
+export type SketchIncidenceGeometry = Readonly<{
+  points: readonly SketchPosition[];
+  lines: SketchSolveProblem['lines'];
+  circles: readonly Pick<
+    SketchSolveProblem['circles'][number],
+    'center' | 'radius'
+  >[];
+  arcs: readonly Omit<SketchSolveProblem['arcs'][number], 'locked'>[];
+}>;
+export type SketchIncidence = Readonly<{
+  point: number;
+  kind: 'line' | 'circle' | 'arc';
+  index: number;
+}>;
+
+export function sketchIncidenceGeometry(
+  problem: SketchSolveProblem,
+  result?: SketchSolveResult,
+): SketchIncidenceGeometry {
+  return {
+    points: result?.positions ?? problem.points.map(p => p.position),
+    lines: problem.lines,
+    circles: problem.circles.map((c, i) => ({
+      ...c,
+      radius: result ? result.radii[i] : c.radius,
+    })),
+    arcs: problem.arcs.map((a, i) => ({
+      ...a,
+      radius: result ? result.arcRadii[i] : a.radius,
+    })),
+  };
+}
+
+export function sketchIncidenceCurve(
+  geometry: SketchIncidenceGeometry,
+  contact: SketchIncidence,
+): SketchCurve {
+  if (contact.kind === 'line')
+    return {
+      kind: 'line',
+      points: geometry.lines[contact.index].map(i => geometry.points[i]) as [
+        SketchPosition,
+        SketchPosition,
+      ],
+    };
+  const curve = (contact.kind === 'circle' ? geometry.circles : geometry.arcs)[
+    contact.index
+  ];
+  const center = geometry.points[curve.center];
+  if (contact.kind === 'circle')
+    return {kind: 'circle', center, radius: curve.radius};
+  const arc = geometry.arcs[contact.index];
+  return {
+    ...sketchArcGeometry(
+      center,
+      geometry.points[arc.points[0]],
+      geometry.points[arc.points[1]],
+      arc.direction,
+    ),
+    radius: arc.radius,
+  };
+}
+
+export function sketchIncidencePoints(
+  geometry: SketchIncidenceGeometry,
+  contact: SketchIncidence,
+): readonly number[] {
+  return [
+    contact.point,
+    ...(contact.kind === 'line'
+      ? geometry.lines[contact.index]
+      : contact.kind === 'circle'
+        ? [geometry.circles[contact.index].center]
+        : [
+            geometry.arcs[contact.index].center,
+            ...geometry.arcs[contact.index].points,
+          ]),
+  ];
+}
+
+export function isPointOnSketchCurve(
+  point: SketchPosition,
+  curve: SketchCurve,
+): boolean {
+  if (curve.kind === 'line')
+    return isPointOnSketchSegment(point, ...curve.points);
+  const nearest = sketchCurvePosition(
+    curve,
+    sketchCurveClosestParameter(curve, point),
+  );
+  return (
+    Math.hypot(point[0] - nearest[0], point[1] - nearest[1]) <=
+    sketchCurveTolerance(curve)
+  );
+}
+
+/** Finite boundary violated by a solution on the underlying unbounded curve. */
+export function sketchIncidenceBoundary(
+  geometry: SketchIncidenceGeometry,
+  contact: SketchIncidence,
+): number | undefined {
+  if (contact.kind === 'circle') return;
+  const curve = sketchIncidenceCurve(geometry, contact);
+  const point = geometry.points[contact.point];
+  if (isPointOnSketchCurve(point, curve)) return;
+  const endpoints =
+    contact.kind === 'line'
+      ? geometry.lines[contact.index]
+      : geometry.arcs[contact.index].points;
+  const t = sketchCurveClosestParameter(curve, point);
+  if (t === 0 || t === 1) return endpoints[t];
+  return;
+}
+
+/** Recognition is gesture-local and shares finite geometry/tolerance with trimming. */
+export function sketchIncidences(
+  geometry: SketchIncidenceGeometry,
+): readonly SketchIncidence[] {
+  const seen = new Set<string>();
+  return (['line', 'circle', 'arc'] as const).flatMap(kind => {
+    const curves =
+      kind === 'line'
+        ? geometry.lines
+        : kind === 'circle'
+          ? geometry.circles
+          : geometry.arcs;
+    return curves.flatMap((_, index) =>
+      geometry.points.flatMap((position, point): SketchIncidence[] => {
+        const contact = {point, kind, index};
+        if (sketchIncidencePoints(geometry, contact).slice(1).includes(point))
+          return [];
+        if (
+          !isPointOnSketchCurve(
+            position,
+            sketchIncidenceCurve(geometry, contact),
+          )
+        )
+          return [];
+        const key =
+          kind === 'line'
+            ? [point, ...[...geometry.lines[index]].sort((a, b) => a - b)].join(
+                ':',
+              )
+            : kind + ':' + point + ':' + index;
+        if (seen.has(key)) return [];
+        seen.add(key);
+        return [contact];
+      }),
+    );
+  });
+}
+
+export function lineParameter(
+  point: SketchPosition,
+  a: SketchPosition,
+  b: SketchPosition,
+): number {
+  const dx = b[0] - a[0],
+    dy = b[1] - a[1];
+  const length = Math.hypot(dx, dy);
+  return (
+    ((point[0] - a[0]) * (dx / length) + (point[1] - a[1]) * (dy / length)) /
+    length
+  );
+}
+
+export function pointLineDistance(
+  point: SketchPosition,
+  a: SketchPosition,
+  b: SketchPosition,
+): number {
+  const dx = b[0] - a[0],
+    dy = b[1] - a[1];
+  const length = Math.hypot(dx, dy);
+  return Math.abs(
+    (point[0] - a[0]) * (dy / length) - (point[1] - a[1]) * (dx / length),
+  );
+}
+
+export function isPointOnSketchSegment(
+  point: SketchPosition,
+  a: SketchPosition,
+  b: SketchPosition,
+): boolean {
+  const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+  if (!length) return false;
+  const tolerance = sketchCurveTolerance({kind: 'line', points: [a, b]});
+  const t = lineParameter(point, a, b);
+  return (
+    t >= -tolerance / length &&
+    t <= 1 + tolerance / length &&
+    pointLineDistance(point, a, b) <= tolerance
+  );
+}

package/src/library/sketch-precision.ts

@@ -0,0 +1,81 @@
+import type {SketchSolveProblem} from './sketch-solver.js';
+
+export const sketchRelativePrecision = 1e-9;
+
+/** Feature-local numeric budget, independent of screen/grid size or decimal
+ * count. Native normalized steps and decimal cleanup use fractions of it.
+ * An unrelated large object must not erase a deliberate small feature.
+ */
+export class SketchPrecision {
+  readonly relative = sketchRelativePrecision;
+  /** Reject invalid native output before the stricter local cleanup check. */
+  readonly nativeAcceptance = this.relative * 100;
+  readonly pointScales: readonly number[];
+  readonly origin: readonly [number, number];
+  readonly scale: number;
+  readonly convergence: number;
+
+  constructor(problem: SketchSolveProblem) {
+    this.origin = problem.points[0]?.position ?? [0, 0];
+    this.pointScales = problem.points.map((point, index) => {
+      const sizes = [
+        ...problem.lines
+          .filter(line => line.includes(index))
+          .map(([a, b]) =>
+            Math.hypot(
+              ...problem.points[a].position.map(
+                (v, axis) => v - problem.points[b].position[axis],
+              ),
+            ),
+          ),
+        ...problem.circles.filter(c => c.center === index).map(c => c.radius),
+        ...problem.arcs
+          .filter(a => a.center === index || a.points.includes(index))
+          .map(a => a.radius),
+      ].filter(size => size > 0);
+      return sizes.length
+        ? Math.min(...sizes)
+        : Math.max(...point.position.map(Math.abs)) || 1;
+    });
+    this.scale =
+      Math.max(
+        ...problem.points.flatMap(p =>
+          p.position.map((v, axis) => Math.abs(v - this.origin[axis])),
+        ),
+        ...problem.circles.map(c => c.radius),
+        ...problem.arcs.map(a => a.radius),
+        ...problem.constraints.flatMap(c =>
+          c.kind === 'length' || c.kind === 'radius' ? [c.value] : [],
+        ),
+      ) || 1;
+    this.convergence = Math.max(
+      Number.EPSILON * 8,
+      ((Math.min(this.scale, ...this.pointScales) / this.scale) *
+        this.relative) /
+        10000,
+    );
+  }
+
+  tolerance(scale: number, value = 0): number {
+    return Math.max(
+      scale * this.relative,
+      Math.abs(value) * Number.EPSILON * 8,
+    );
+  }
+
+  clean(value: number, scale: number, preferred: readonly number[]): number {
+    const tolerance = this.tolerance(scale, value);
+    for (const target of preferred)
+      if (Math.abs(target - value) <= tolerance) return target;
+    const rounding = Math.max(
+      (scale * this.relative) / 100,
+      Math.abs(value) * Number.EPSILON * 8,
+    );
+    if (Math.abs(value) <= rounding) return 0;
+    for (let digits = 1; digits < 16; digits++) {
+      const rounded = Number(value.toPrecision(digits));
+      if (Math.abs(rounded - value) <= rounding) return rounded;
+    }
+    return value;
+  }
+}

package/src/library/sketch-regions.ts

@@ -0,0 +1,271 @@
+import {
+  sketchPointResolver,
+  type SketchSnapshot,
+  type SketchPosition,
+} from './sketch.js';
+import {
+  sketchCurveGeometry,
+  sketchCurvePosition,
+  sketchCurveTolerance,
+  sketchPositiveAngle,
+  type SketchCurve,
+} from './sketch-curves.js';
+import {sketchCurveIntersections} from './sketch-curve-intersections.js';
+import {isPointOnSketchCurve} from './sketch-incidence.js';
+
+/** Evaluation-local boundaries. Neither array order nor a kernel wire is an author ID. */
+export type SketchRegion = Readonly<{
+  outer: readonly SketchCurve[];
+  holes: readonly (readonly SketchCurve[])[];
+}>;
+
+type Boundary = {
+  curve: SketchCurve;
+  label: string;
+  ends?: readonly [number, number];
+};
+const tau = 2 * Math.PI;
+const distance = (a: SketchPosition, b: SketchPosition) =>
+  Math.hypot(a[0] - b[0], a[1] - b[1]);
+
+/** Closed, non-intersecting contours; nested contours alternate material and holes. */
+export function sketchRegions(
+  layers: readonly SketchSnapshot[],
+): readonly SketchRegion[] {
+  const resolve = sketchPointResolver(layers);
+  const points = new Map(
+    layers.flatMap(layer =>
+      layer.entities.flatMap(e =>
+        e.kind === 'point'
+          ? [[JSON.stringify([layer.id, e.id]), e.position] as const]
+          : [],
+      ),
+    ),
+  );
+  const boundaries: Boundary[] = layers.flatMap(layer =>
+    layer.entities.flatMap(entity => {
+      const curve = sketchCurveGeometry(entity, ref => {
+        const point = resolve(ref);
+        return points.get(JSON.stringify([point.layer, point.id]))!;
+      });
+      return curve ? [{curve, label: `${layer.id}:${entity.id}`}] : [];
+    }),
+  );
+  const vertices: {
+    position: SketchPosition;
+    tolerance: number;
+    edges: number[];
+  }[] = [];
+  const vertex = (position: SketchPosition, tolerance: number) => {
+    const index = vertices.findIndex(
+      v => distance(v.position, position) <= Math.min(v.tolerance, tolerance),
+    );
+    if (index >= 0) return index;
+    vertices.push({position, tolerance, edges: []});
+    return vertices.length - 1;
+  };
+  for (const [i, boundary] of boundaries.entries()) {
+    const {curve} = boundary;
+    if (curve.kind === 'circle') continue;
+    const tolerance = sketchCurveTolerance(curve);
+    const ends = [
+      vertex(sketchCurvePosition(curve, 0), tolerance),
+      vertex(sketchCurvePosition(curve, 1), tolerance),
+    ] as const;
+    if (ends[0] === ends[1])
+      throw new Error(`Sketch boundary ${boundary.label} is degenerate.`);
+    boundary.ends = ends;
+    ends.forEach(v => vertices[v].edges.push(i));
+  }
+  for (let i = 0; i < boundaries.length; i++) {
+    const a = boundaries[i];
+    for (const b of boundaries.slice(i + 1)) {
+      const contacts = sketchCurveIntersections(a.curve, b.curve);
+      if (
+        overlap(
+          a.curve,
+          b.curve,
+          contacts.map(c => c.parameters[0]),
+        ) ||
+        contacts.some(c =>
+          c.parameters.some((_, j) => {
+            const curve = j === 0 ? a.curve : b.curve;
+            return (
+              curve.kind === 'circle' ||
+              (distance(c.position, sketchCurvePosition(curve, 0)) >
+                sketchCurveTolerance(curve) &&
+                distance(c.position, sketchCurvePosition(curve, 1)) >
+                  sketchCurveTolerance(curve))
+            );
+          }),
+        )
+      )
+        throw new Error(
+          `Sketch boundaries ${a.label} and ${b.label} intersect or overlap. Trim them into separate closed contours before creating faces.`,
+        );
+    }
+  }
+  for (const v of vertices) {
+    if (v.edges.length !== 2)
+      throw new Error(
+        `Sketch has an ${v.edges.length === 1 ? 'open' : 'ambiguous branching'} contour at [${v.position.join(', ')}]. Faces require closed, non-branching boundaries.`,
+      );
+  }
+  const visited = new Set<number>();
+  const loops: SketchCurve[][] = [];
+  for (const [start, boundary] of boundaries.entries()) {
+    if (visited.has(start)) continue;
+    if (!boundary.ends) {
+      visited.add(start);
+      loops.push([boundary.curve]);
+      continue;
+    }
+    const curves: SketchCurve[] = [];
+    let edge = start,
+      from = boundary.ends[0];
+    do {
+      const current = boundaries[edge];
+      const forward = current.ends![0] === from;
+      curves.push(forward ? current.curve : reverseCurve(current.curve));
+      visited.add(edge);
+      from = current.ends![forward ? 1 : 0];
+      edge = vertices[from].edges.find(e => e !== edge)!;
+    } while (edge !== start);
+    const area = contourArea(curves);
+    if (Math.abs(area) <= Math.max(...curves.map(sketchCurveTolerance)) ** 2)
+      throw new Error('Sketch contour has no finite area.');
+    loops.push(area < 0 ? curves.reverse().map(reverseCurve) : curves);
+  }
+  const areas = loops.map(loop => Math.abs(contourArea(loop)));
+  const parents = loops.map((loop, i) => {
+    const p = sketchCurvePosition(loop[0], 0);
+    const enclosing = loops.flatMap((other, j) =>
+      j !== i && areas[j] > areas[i] && contourContains(other, p) ? [j] : [],
+    );
+    return enclosing.sort((a, b) => areas[a] - areas[b])[0];
+  });
+  const depth = (i: number): number =>
+    parents[i] === undefined ? 0 : 1 + depth(parents[i]);
+  return loops.flatMap((outer, i) =>
+    depth(i) % 2
+      ? []
+      : [
+          {
+            outer,
+            holes: loops
+              .filter((_, j) => parents[j] === i)
+              .map(loop => [...loop].reverse().map(reverseCurve)),
+          },
+        ],
+  );
+}
+
+function reverseCurve(curve: SketchCurve): SketchCurve {
+  if (curve.kind === 'line')
+    return {...curve, points: [curve.points[1], curve.points[0]]};
+  if (curve.kind === 'arc')
+    return {...curve, start: curve.start + curve.sweep, sweep: -curve.sweep};
+  // A full circular hole needs an explicit clockwise traversal too.
+  return {
+    kind: 'arc',
+    center: curve.center,
+    radius: curve.radius,
+    start: 0,
+    sweep: -tau,
+  };
+}
+
+function overlap(
+  a: SketchCurve,
+  b: SketchCurve,
+  intersections: readonly number[],
+): boolean {
+  if (a.kind === 'line' || b.kind === 'line') {
+    if (a.kind !== 'line' || b.kind !== 'line' || intersections.length < 2)
+      return false;
+  } else if (
+    distance(a.center, b.center) >
+      Math.min(sketchCurveTolerance(a), sketchCurveTolerance(b)) ||
+    Math.abs(a.radius - b.radius) >
+      Math.min(sketchCurveTolerance(a), sketchCurveTolerance(b))
+  )
+    return false;
+  const cuts = [0, ...intersections, 1].sort((a, b) => a - b);
+  return cuts
+    .slice(1)
+    .some(
+      (end, i) =>
+        end > cuts[i] &&
+        isPointOnSketchCurve(sketchCurvePosition(a, (cuts[i] + end) / 2), b),
+    );
+}
+
+/** Green's theorem, translated near the contour to avoid large-offset cancellation. */
+export function contourArea(curves: readonly SketchCurve[]): number {
+  if (!curves.length) return 0;
+  const origin = sketchCurvePosition(curves[0], 0);
+  return curves.reduce((area, curve) => {
+    if (curve.kind === 'line') {
+      const [a, b] = curve.points.map(p => [
+        p[0] - origin[0],
+        p[1] - origin[1],
+      ]);
+      return area + (a[0] * b[1] - b[0] * a[1]) / 2;
+    }
+    if (curve.kind === 'circle') return area + Math.PI * curve.radius ** 2;
+    const [x, y] = [curve.center[0] - origin[0], curve.center[1] - origin[1]];
+    const a = curve.start,
+      b = a + curve.sweep,
+      r = curve.radius;
+    return (
+      area +
+      (r * (x * (Math.sin(b) - Math.sin(a)) - y * (Math.cos(b) - Math.cos(a))) +
+        r * r * curve.sweep) /
+        2
+    );
+  }, 0);
+}
+
+/** Analytic horizontal ray crossings, with half-open, Y-monotone curve pieces. */
+function contourContains(
+  curves: readonly SketchCurve[],
+  point: SketchPosition,
+): boolean {
+  let crossings = 0;
+  for (const curve of curves) {
+    if (curve.kind === 'line') {
+      const [a, b] = curve.points;
+      if (
+        a[1] > point[1] !== b[1] > point[1] &&
+        a[0] + ((point[1] - a[1]) * (b[0] - a[0])) / (b[1] - a[1]) > point[0]
+      )
+        crossings++;
+      continue;
+    }
+    const start = curve.kind === 'circle' ? 0 : curve.start;
+    const sweep = curve.kind === 'circle' ? tau : curve.sweep;
+    const cuts = [
+      0,
+      1,
+      ...[Math.PI / 2, (3 * Math.PI) / 2]
+        .map(
+          a =>
+            sketchPositiveAngle(Math.sign(sweep) * (a - start)) /
+            Math.abs(sweep),
+        )
+        .filter(t => t > 0 && t < 1),
+    ].sort((a, b) => a - b);
+    for (let i = 1; i < cuts.length; i++) {
+      const a = sketchCurvePosition(curve, cuts[i - 1]),
+        b = sketchCurvePosition(curve, cuts[i]);
+      if (a[1] > point[1] === b[1] > point[1]) continue;
+      const dy = point[1] - curve.center[1];
+      const x =
+        curve.center[0] +
+        Math.sign(Math.cos(start + (sweep * (cuts[i - 1] + cuts[i])) / 2)) *
+          Math.sqrt(Math.max(0, (curve.radius - dy) * (curve.radius + dy)));
+      if (x > point[0]) crossings++;
+    }
+  }
+  return crossings % 2 === 1;
+}