@code3d/core 0.0.1-alpha.0

package/src/library/shell.ts

@@ -0,0 +1,281 @@
+import {formatTopologyId, TopologyIdSet} from './topology-id.js';
+import {getOC, type Shape3D} from 'replicad';
+import {castOwnedShape3D, shapeSubshapes} from './kernel-shapes.js';
+import {describeOpenCascadeException} from './open-cascade-error.js';
+import {
+  transferShapeTopology,
+  type ShapeTopology,
+  type SurfaceId,
+} from './topology.js';
+
+const tolerance = 0.001;
+
+export function shellWithTopology(
+  shape: Shape3D,
+  topology: ShapeTopology,
+  thickness: number,
+  removedSurfaceIds: readonly SurfaceId[],
+): {shape: Shape3D; topology: ShapeTopology} {
+  const selection = removedSurfaceIds.length
+    ? removedSurfaceIds.map(id => formatTopologyId('surface', id)).join(', ')
+    : 'no openings';
+  try {
+    if (removedSurfaceIds.length === topology.surfaces.ids.length) {
+      throw new Error('At least one surface must remain as a wall.');
+    }
+    const solid = singleSolid(shape);
+    try {
+      const volume = validVolume(solid);
+      return removedSurfaceIds.length
+        ? openShell(solid, topology, thickness, removedSurfaceIds, volume)
+        : closedShell(solid, topology, thickness, volume);
+    } finally {
+      solid.delete();
+    }
+  } catch (error) {
+    const detail =
+      describeOpenCascadeException(error) ??
+      (error instanceof Error ? error.message : String(error));
+    throw new Error(
+      `Could not construct shell with thickness ${thickness} and ${selection}.\n` +
+        `${detail} Try simplifying the geometry or changing the thickness or openings.`,
+      {cause: error},
+    );
+  }
+}
+
+function openShell(
+  shape: Shape3D,
+  topology: ShapeTopology,
+  thickness: number,
+  removedIds: readonly SurfaceId[],
+  sourceVolume: number,
+): {shape: Shape3D; topology: ShapeTopology} {
+  const oc = getOC();
+  const faces = shapeSubshapes(shape, 'face');
+  const selected = new TopologyIdSet(removedIds);
+  const closingFaces = new oc.NCollection_List_TopoDS_Shape();
+  const builder = new oc.BRepOffsetAPI_MakeThickSolid();
+  let result: Shape3D | undefined;
+  try {
+    faces.forEach((face, index) => {
+      if (selected.has(topology.surfaces.ids[index]))
+        closingFaces.Append(face.wrapped);
+    });
+    builder.MakeThickSolidByJoin(
+      shape.wrapped,
+      closingFaces,
+      -thickness,
+      tolerance,
+      oc.BRepOffset_Mode.BRepOffset_Skin,
+      false,
+      false,
+      oc.GeomAbs_JoinType.GeomAbs_Arc,
+      false,
+    );
+    if (!builder.IsDone())
+      throw new Error('OpenCascade could not build the offset walls.');
+    const raw = castOwnedShape3D(builder.Shape());
+    try {
+      result = singleSolid(raw);
+    } finally {
+      raw.delete();
+    }
+    const volume = validVolume(result);
+    const outputFaces = shapeSubshapes(result, 'face');
+    try {
+      // IsDone/IsValid can both succeed without offset walls, including on
+      // mixed-profile lofts. Diagnose that before comparing solid volumes.
+      const hasOffsetWall = faces.some((face, index) => {
+        if (selected.has(topology.surfaces.ids[index])) return false;
+        const generated = builder.Generated(face.wrapped);
+        try {
+          while (!generated.IsEmpty()) {
+            const candidate = generated.First();
+            generated.RemoveFirst();
+            try {
+              if (outputFaces.some(output => output.wrapped.IsSame(candidate)))
+                return true;
+            } finally {
+              candidate.delete();
+            }
+          }
+          return false;
+        } finally {
+          generated.delete();
+        }
+      });
+      if (!hasOffsetWall) {
+        throw new Error(
+          'OpenCascade generated no offset walls for this geometry; the result is not hollow.',
+        );
+      }
+    } finally {
+      outputFaces.forEach(face => face.delete());
+    }
+    if (thickness > 0 && volume >= sourceVolume) {
+      throw new Error('The inward offset did not leave a cavity.');
+    }
+    return {
+      shape: result,
+      topology: transferShapeTopology(
+        [{shape, topology, index: 1}],
+        result,
+        builder,
+      ),
+    };
+  } catch (error) {
+    result?.delete();
+    throw error;
+  } finally {
+    builder.delete();
+    closingFaces.delete();
+    faces.forEach(face => face.delete());
+  }
+}
+
+function closedShell(
+  shape: Shape3D,
+  topology: ShapeTopology,
+  thickness: number,
+  sourceVolume: number,
+): {shape: Shape3D; topology: ShapeTopology} {
+  const oc = getOC();
+  const offset = new oc.BRepOffsetAPI_MakeOffsetShape();
+  let parallel: Shape3D | undefined;
+  try {
+    // MakeThickSolidByJoin with no closing faces returns only the offset solid.
+    offset.PerformByJoin(
+      shape.wrapped,
+      -thickness,
+      tolerance,
+      oc.BRepOffset_Mode.BRepOffset_Skin,
+      false,
+      false,
+      oc.GeomAbs_JoinType.GeomAbs_Arc,
+      false,
+    );
+    if (!offset.IsDone())
+      throw new Error('OpenCascade could not build the cavity offset.');
+    const raw = castOwnedShape3D(offset.Shape());
+    try {
+      parallel = singleSolid(raw);
+    } finally {
+      raw.delete();
+    }
+    const offsetVolume = validVolume(parallel);
+    if (
+      thickness > 0
+        ? offsetVolume >= sourceVolume
+        : offsetVolume <= sourceVolume
+    ) {
+      throw new Error('The offset did not produce a distinct cavity boundary.');
+    }
+    const cut = new oc.BRepAlgoAPI_Cut(
+      thickness > 0 ? shape.wrapped : parallel.wrapped,
+      thickness > 0 ? parallel.wrapped : shape.wrapped,
+    );
+    let result: Shape3D | undefined;
+    try {
+      cut.Build();
+      if (!cut.IsDone())
+        throw new Error('OpenCascade could not subtract the cavity.');
+      const rawResult = castOwnedShape3D(cut.Shape());
+      try {
+        result = singleSolid(rawResult);
+      } finally {
+        rawResult.delete();
+      }
+      validVolume(result);
+      const shells = new oc.TopExp_Explorer(
+        result.wrapped,
+        oc.TopAbs_ShapeEnum.TopAbs_SHELL,
+      );
+      try {
+        let count = 0;
+        while (shells.More()) {
+          count++;
+          shells.Next();
+        }
+        if (count < 2)
+          throw new Error('The offset did not form an enclosed cavity.');
+      } finally {
+        shells.delete();
+      }
+      // Original boundaries retain their input paths for either direction. Offset
+      // boundaries are new topology, even when OCCT has generation history.
+      return {
+        shape: result,
+        topology: transferShapeTopology(
+          [{shape, topology, index: 1}],
+          result,
+          cut,
+        ),
+      };
+    } catch (error) {
+      result?.delete();
+      throw error;
+    } finally {
+      cut.delete();
+    }
+  } finally {
+    parallel?.delete();
+    offset.delete();
+  }
+}
+
+/** Own one solid independently of its enclosing boolean compound or builder. */
+function singleSolid(shape: Shape3D): Shape3D {
+  const oc = getOC();
+  const explorer = new oc.TopExp_Explorer(
+    shape.wrapped,
+    oc.TopAbs_ShapeEnum.TopAbs_SOLID,
+  );
+  let solid: Shape3D | undefined;
+  try {
+    if (!explorer.More())
+      throw new Error('Shell requires one connected solid.');
+    solid = castOwnedShape3D(explorer.Current());
+    explorer.Next();
+    if (explorer.More()) throw new Error('Shell requires one connected solid.');
+    return solid;
+  } catch (error) {
+    solid?.delete();
+    throw error;
+  } finally {
+    explorer.delete();
+  }
+}
+
+function validVolume(shape: Shape3D): number {
+  const check = new (getOC().BRepCheck_Analyzer)(
+    shape.wrapped,
+    true,
+    false,
+    false,
+  );
+  try {
+    if (!check.IsValid())
+      throw new Error('The offset geometry is invalid or self-intersecting.');
+  } finally {
+    check.delete();
+  }
+  const oc = getOC();
+  const properties = new oc.GProp_GProps();
+  try {
+    oc.BRepGProp.VolumeProperties(
+      shape.wrapped,
+      properties,
+      false,
+      false,
+      false,
+    );
+    const volume = properties.Mass();
+    if (!(Number.isFinite(volume) && volume > 0)) {
+      throw new Error('The offset geometry has no positive solid volume.');
+    }
+    return volume;
+  } finally {
+    properties.delete();
+  }
+}

package/src/library/sketch-curve-intersections.ts

@@ -0,0 +1,154 @@
+import type {SketchPosition} from './sketch.js';
+import {
+  sketchCurveClosestParameter,
+  sketchCurvePosition,
+  sketchCurveTolerance,
+  type SketchCurve,
+} from './sketch-curves.js';
+
+export type SketchCurveIntersection = Readonly<{
+  position: SketchPosition;
+  parameters: readonly [first: number, second: number];
+}>;
+
+const subtract = (a: SketchPosition, b: SketchPosition): SketchPosition => [
+  a[0] - b[0],
+  a[1] - b[1],
+];
+const cross = (a: SketchPosition, b: SketchPosition) =>
+  a[0] * b[1] - a[1] * b[0];
+const distance = (a: SketchPosition, b: SketchPosition) =>
+  Math.hypot(...subtract(a, b));
+const endpoints = (curve: SketchCurve): readonly SketchPosition[] =>
+  curve.kind === 'circle'
+    ? []
+    : [sketchCurvePosition(curve, 0), sketchCurvePosition(curve, 1)];
+
+/**
+ * Isolated intersections and finite overlap boundaries, ordered along first.
+ * A shared continuous interior does not enumerate points: coincident full
+ * circles have no boundaries. Parameters are local to this evaluation, not IDs.
+ */
+export function sketchCurveIntersections(
+  first: SketchCurve,
+  second: SketchCurve,
+): readonly SketchCurveIntersection[] {
+  const tolerances = [
+    sketchCurveTolerance(first),
+    sketchCurveTolerance(second),
+  ];
+  const tolerance = Math.min(...tolerances);
+  const contacts: SketchCurveIntersection[] = [];
+  for (const position of candidates(first, second, tolerance)) {
+    const parameters = [
+      sketchCurveClosestParameter(first, position),
+      sketchCurveClosestParameter(second, position),
+    ] as const;
+    if (
+      [first, second].some(
+        (curve, i) =>
+          distance(position, sketchCurvePosition(curve, parameters[i])) >
+          tolerances[i],
+      ) ||
+      contacts.some(
+        contact => distance(position, contact.position) <= tolerance,
+      )
+    )
+      continue;
+    contacts.push({position, parameters});
+  }
+  return contacts.sort((a, b) => a.parameters[0] - b.parameters[0]);
+}
+
+function candidates(
+  first: SketchCurve,
+  second: SketchCurve,
+  tolerance: number,
+): readonly SketchPosition[] {
+  if (first.kind === 'line') {
+    const [a, b] = first.points;
+    const length = distance(a, b);
+    if (!length) return [a];
+    const unit: SketchPosition = [
+      (b[0] - a[0]) / length,
+      (b[1] - a[1]) / length,
+    ];
+    if (second.kind === 'line') {
+      const [c, d] = second.points;
+      const otherLength = distance(c, d);
+      if (!otherLength) return [c];
+      // Collinear endpoints delimit overlap. Check them before dividing by
+      // the angle, which can be roundoff-sized for rotated/translated lines.
+      if (
+        second.points.every(
+          p => Math.abs(cross(unit, subtract(p, a))) <= tolerance,
+        )
+      )
+        return [a, b, c, d];
+      const otherUnit: SketchPosition = [
+        (d[0] - c[0]) / otherLength,
+        (d[1] - c[1]) / otherLength,
+      ];
+      const denominator = cross(unit, otherUnit);
+      if (Math.abs(denominator) <= Number.EPSILON * 16) return [];
+      const along = cross(subtract(c, a), otherUnit) / denominator;
+      return [[a[0] + along * unit[0], a[1] + along * unit[1]]];
+    }
+    const perpendicular = cross(unit, subtract(second.center, a));
+    const gap = Math.abs(perpendicular);
+    if (gap > second.radius + tolerance) return [];
+    const normalized = gap / second.radius;
+    // Classify tangency before sqrt magnifies coordinate roundoff into two
+    // artificial cuts. Use the same model-space tolerance as finite contacts.
+    const offset =
+      Math.abs(gap - second.radius) <= tolerance
+        ? 0
+        : second.radius *
+          Math.sqrt(Math.max(0, (1 - normalized) * (1 + normalized)));
+    // Start at the circular center's projection, not a far-away line endpoint.
+    const foot: SketchPosition = [
+      second.center[0] + perpendicular * unit[1],
+      second.center[1] - perpendicular * unit[0],
+    ];
+    return [-offset, offset].map(along => [
+      foot[0] + along * unit[0],
+      foot[1] + along * unit[1],
+    ]);
+  }
+  if (second.kind === 'line') return candidates(second, first, tolerance);
+  const delta = subtract(second.center, first.center);
+  const separation = Math.hypot(...delta);
+  if (
+    separation <= tolerance &&
+    Math.abs(first.radius - second.radius) <= tolerance
+  )
+    return [...endpoints(first), ...endpoints(second)];
+  if (
+    !separation ||
+    separation > first.radius + second.radius + tolerance ||
+    separation < Math.abs(first.radius - second.radius) - tolerance
+  )
+    return [];
+  // Normalize before squaring; the factored radius difference also avoids
+  // subtracting nearly equal squared radii.
+  const scale = Math.max(separation, first.radius, second.radius);
+  const d = separation / scale,
+    r = first.radius / scale,
+    s = second.radius / scale;
+  const along = (d * d + (r - s) * (r + s)) / (2 * d);
+  const tangent =
+    Math.abs(separation - first.radius - second.radius) <= tolerance ||
+    Math.abs(separation - Math.abs(first.radius - second.radius)) <= tolerance;
+  const height = tangent
+    ? 0
+    : Math.sqrt(Math.max(0, (r - along) * (r + along))) * scale;
+  const unit: SketchPosition = [delta[0] / separation, delta[1] / separation];
+  const foot: SketchPosition = [
+    first.center[0] + along * scale * unit[0],
+    first.center[1] + along * scale * unit[1],
+  ];
+  return [-height, height].map(offset => [
+    foot[0] - offset * unit[1],
+    foot[1] + offset * unit[0],
+  ]);
+}

package/src/library/sketch-curves.ts

@@ -0,0 +1,161 @@
+import {sketchRelativePrecision} from './sketch-precision.js';
+import type {
+  SketchArcDirection,
+  SketchEntitySnapshot,
+  SketchPointAddress,
+  SketchPosition,
+} from './sketch.js';
+
+/** Analytic geometry only. Parameters are evaluation-local, never entity identity. */
+export type SketchCurve =
+  | Readonly<{kind: 'line'; points: readonly [SketchPosition, SketchPosition]}>
+  | Readonly<{kind: 'circle'; center: SketchPosition; radius: number}>
+  | Readonly<{
+      kind: 'arc';
+      center: SketchPosition;
+      radius: number;
+      start: number;
+      sweep: number;
+    }>;
+
+const tau = Math.PI * 2;
+export const sketchPositiveAngle = (angle: number) =>
+  ((angle % tau) + tau) % tau;
+
+export function sketchArcGeometry(
+  center: SketchPosition,
+  start: SketchPosition,
+  end: SketchPosition,
+  direction: SketchArcDirection,
+): Extract<SketchCurve, {kind: 'arc'}> {
+  const angle = Math.atan2(start[1] - center[1], start[0] - center[0]);
+  const endAngle = Math.atan2(end[1] - center[1], end[0] - center[0]);
+  const sign = direction === 'ccw' ? 1 : -1;
+  return {
+    kind: 'arc',
+    center,
+    radius: Math.hypot(start[0] - center[0], start[1] - center[1]),
+    start: angle,
+    sweep: sign * sketchPositiveAngle(sign * (endAngle - angle)),
+  };
+}
+
+export function sketchCurveGeometry<E extends SketchEntitySnapshot>(
+  entity: E,
+  point: (address: SketchPointAddress) => SketchPosition,
+): E extends {kind: 'point'}
+  ? undefined
+  : Extract<SketchCurve, {kind: E['kind']}>;
+export function sketchCurveGeometry(
+  entity: SketchEntitySnapshot,
+  point: (address: SketchPointAddress) => SketchPosition,
+): SketchCurve | undefined {
+  switch (entity.kind) {
+    case 'point':
+      return undefined;
+    case 'line':
+      return {
+        kind: 'line',
+        points: [point(entity.points[0]), point(entity.points[1])],
+      };
+    case 'circle':
+      return {
+        kind: 'circle',
+        center: point(entity.center),
+        radius: entity.radius,
+      };
+    case 'arc':
+      return {
+        ...sketchArcGeometry(
+          point(entity.center),
+          point(entity.points[0]),
+          point(entity.points[1]),
+          entity.direction,
+        ),
+        radius: entity.radius,
+      };
+  }
+}
+
+export function sketchCurvePosition(
+  curve: SketchCurve,
+  t: number,
+): SketchPosition {
+  if (curve.kind === 'line') {
+    const [a, b] = curve.points;
+    return [a[0] + t * (b[0] - a[0]), a[1] + t * (b[1] - a[1])];
+  }
+  const angle =
+    curve.kind === 'circle' ? t * tau : curve.start + t * curve.sweep;
+  return [
+    curve.center[0] + curve.radius * Math.cos(angle),
+    curve.center[1] + curve.radius * Math.sin(angle),
+  ];
+}
+
+/** Nearest point on the finite curve, including arc endpoints (not its full circle). */
+export function sketchCurveClosestParameter(
+  curve: SketchCurve,
+  position: SketchPosition,
+): number {
+  if (curve.kind === 'line') {
+    const [a, b] = curve.points,
+      dx = b[0] - a[0],
+      dy = b[1] - a[1];
+    return Math.max(
+      0,
+      Math.min(
+        1,
+        ((position[0] - a[0]) * dx + (position[1] - a[1]) * dy) /
+          (dx * dx + dy * dy) || 0,
+      ),
+    );
+  }
+  const angle = Math.atan2(
+    position[1] - curve.center[1],
+    position[0] - curve.center[0],
+  );
+  if (curve.kind === 'circle') return sketchPositiveAngle(angle) / tau;
+  const sign = Math.sign(curve.sweep),
+    sweep = Math.abs(curve.sweep);
+  const distance = sketchPositiveAngle(sign * (angle - curve.start));
+  if (distance <= sweep) return sweep ? distance / sweep : 0;
+  return distance - sweep < tau - distance ? 1 : 0;
+}
+
+export function sketchCurveBounds(
+  curve: SketchCurve,
+): readonly SketchPosition[] {
+  if (curve.kind === 'line') return curve.points;
+  const candidates = [0, Math.PI / 2, Math.PI, (3 * Math.PI) / 2].filter(
+    angle =>
+      curve.kind === 'circle' ||
+      sketchPositiveAngle(Math.sign(curve.sweep) * (angle - curve.start)) <=
+        Math.abs(curve.sweep),
+  );
+  return [
+    ...(curve.kind === 'arc'
+      ? [sketchCurvePosition(curve, 0), sketchCurvePosition(curve, 1)]
+      : []),
+    ...candidates.map((angle): SketchPosition => [
+      curve.center[0] + curve.radius * Math.cos(angle),
+      curve.center[1] + curve.radius * Math.sin(angle),
+    ]),
+  ];
+}
+
+export function sketchCurveTolerance(curve: SketchCurve): number {
+  const size =
+    curve.kind === 'line'
+      ? Math.hypot(
+          curve.points[1][0] - curve.points[0][0],
+          curve.points[1][1] - curve.points[0][1],
+        )
+      : curve.radius;
+  return Math.max(
+    size * sketchRelativePrecision,
+    Number.EPSILON *
+      16 *
+      Math.max(...sketchCurveBounds(curve).flatMap(p => p.map(Math.abs))),
+  );
+}