okgeometry-api 1.1.6 → 1.1.7

package/src/PolyCurve.ts

@@ -1,306 +1,306 @@
-import { ensureInit } from "./engine.js";
-import { Point } from "./Point.js";
-import { Line } from "./Line.js";
-import { Arc } from "./Arc.js";
-import { Vec3 } from "./Vec3.js";
-import { NurbsCurve } from "./NurbsCurve.js";
-import type { Plane } from "./Plane.js";
-import type { CurveSegment, RotationAxis } from "./types.js";
-import { SegmentTypeCode } from "./types.js";
-import { pointsToCoords, coordsToPoints } from "./BufferCodec.js";
-import * as wasm from "../wasm/okgeometrycore_bg.js";
-
-/**
- * Composite curve made of sequential Line and Arc segments.
- */
-export class PolyCurve {
-  public readonly segments: CurveSegment[];
-
-  constructor(segments: CurveSegment[]) {
-    this.segments = segments;
-  }
-
-  /** Create a PolyCurve by connecting points with line segments */
-  static byPoints(points: Point[]): PolyCurve {
-    if (points.length < 2) return new PolyCurve([]);
-    const segs: CurveSegment[] = [];
-    for (let i = 0; i < points.length - 1; i++) {
-      segs.push(new Line(points[i], points[i + 1]));
-    }
-    return new PolyCurve(segs);
-  }
-
-  get startPoint(): Point {
-    if (this.segments.length === 0) return Point.ORIGIN;
-    const s = this.segments[0];
-    return s instanceof Line ? s.start : s.pointAt(0);
-  }
-
-  get endPoint(): Point {
-    if (this.segments.length === 0) return Point.ORIGIN;
-    const s = this.segments[this.segments.length - 1];
-    return s instanceof Line ? s.end : s.pointAt(1);
-  }
-
-  /** Returns all constituent curves (Line and Arc segments) in order. */
-  get curves(): CurveSegment[] {
-    return this.segments;
-  }
-
-  /**
-   * Sample all segments into a flat array of points for rendering.
-   * Line segments produce 2 points; Arc segments are sampled with `arcSamples` points.
-   * Consecutive duplicate junction points are removed.
-   */
-  sample(arcSamples = 32): Point[] {
-    const pts: Point[] = [];
-    for (const seg of this.segments) {
-      let segPts: Point[];
-      if (seg instanceof Line) {
-        segPts = [seg.start, seg.end];
-      } else {
-        // Arc: sample into multiple points for smooth rendering
-        segPts = seg.sample(arcSamples);
-      }
-      for (const p of segPts) {
-        // Skip duplicate junction points
-        if (pts.length > 0 && pts[pts.length - 1].equals(p)) continue;
-        pts.push(p);
-      }
-    }
-    return pts;
-  }
-
-  /** Evaluate a point on the curve at normalized parameter t (0 = start, 1 = end). */
-  pointAt(t: number): Point {
-    if (this.segments.length === 0) return Point.ORIGIN;
-    if (t <= 0) return this.startPoint;
-    if (t >= 1) return this.endPoint;
-
-    const lengths = this.segments.map(s => s.length());
-    const total = lengths.reduce((a, b) => a + b, 0);
-    if (total === 0) return this.startPoint;
-
-    let target = t * total;
-    for (let i = 0; i < this.segments.length; i++) {
-      if (target <= lengths[i] || i === this.segments.length - 1) {
-        const localT = lengths[i] > 0 ? target / lengths[i] : 0;
-        return this.segments[i].pointAt(Math.min(localT, 1));
-      }
-      target -= lengths[i];
-    }
-    return this.endPoint;
-  }
-
-  isClosed(eps = 1e-10): boolean {
-    return this.startPoint.equals(this.endPoint, eps);
-  }
-
-  length(): number {
-    return this.segments.reduce((sum, s) => sum + s.length(), 0);
-  }
-
-  rotate(axis: RotationAxis, angle: number): PolyCurve {
-    return new PolyCurve(this.segments.map(s => s.rotate(axis, angle)));
-  }
-
-  translate(offset: Vec3): PolyCurve {
-    return new PolyCurve(this.segments.map(s => s.translate(offset)));
-  }
-
-  projectOntoPlane(plane: Plane, direction?: Vec3, arcSamples = 32): PolyCurve {
-    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
-    const segs: CurveSegment[] = [];
-    for (const s of this.segments) {
-      if (s instanceof Line) {
-        segs.push(new Line(proj(s.start), proj(s.end)));
-      } else {
-        // Arc projects to elliptical arc — approximate with line segments
-        const pts = s.sample(arcSamples);
-        for (let i = 0; i < pts.length - 1; i++) {
-          segs.push(new Line(proj(pts[i]), proj(pts[i + 1])));
-        }
-      }
-    }
-    return new PolyCurve(segs);
-  }
-
-  /**
-   * Fillet corners of this PolyCurve with arcs of the given radius.
-   * Extracts the vertex points, calls WASM fillet_corners, returns a new PolyCurve.
-   */
-  fillet(radius: number, normal?: Vec3): PolyCurve {
-    ensureInit();
-    if (this.segments.length < 2) {
-      throw new Error("PolyCurve.fillet() requires at least 2 segments");
-    }
-
-    // Extract all vertex points from segments
-    const pts: Point[] = [];
-    for (const seg of this.segments) {
-      if (seg instanceof Line) {
-        if (pts.length === 0) pts.push(seg.start);
-        pts.push(seg.end);
-      } else {
-        // Arc: use start and end points
-        if (pts.length === 0) pts.push(seg.pointAt(0));
-        pts.push(seg.pointAt(1));
-      }
-    }
-    if (pts.length < 3) {
-      throw new Error("PolyCurve.fillet() requires at least 3 vertices");
-    }
-
-    const coords = new Float64Array(pts.length * 3);
-    for (let i = 0; i < pts.length; i++) {
-      coords[i * 3] = pts[i].x;
-      coords[i * 3 + 1] = pts[i].y;
-      coords[i * 3 + 2] = pts[i].z;
-    }
-
-    const nx = normal?.x ?? 0, ny = normal?.y ?? 0, nz = normal?.z ?? 0;
-    const buf = wasm.fillet_polycurve(coords, radius, nx, ny, nz);
-    if (buf.length < 1) {
-      throw new Error("PolyCurve.fillet() failed - WASM returned empty result");
-    }
-    return PolyCurve.fromSegmentData(buf);
-  }
-
-  /** Decode a PolyCurve from WASM segment buffer [count, type, ...data, ...] */
-  static fromSegmentData(buf: Float64Array | number[]): PolyCurve {
-    const count = buf[0];
-    const segs: CurveSegment[] = [];
-    let idx = 1;
-    for (let i = 0; i < count; i++) {
-      const type = buf[idx++];
-      if (type === SegmentTypeCode.Line) {
-        // Line: 6 floats
-        const s = new Point(buf[idx], buf[idx + 1], buf[idx + 2]);
-        const e = new Point(buf[idx + 3], buf[idx + 4], buf[idx + 5]);
-        segs.push(new Line(s, e));
-        idx += 6;
-      } else if (type === SegmentTypeCode.Arc) {
-        // Arc: 9 floats
-        const center = new Point(buf[idx], buf[idx + 1], buf[idx + 2]);
-        const normal = new Vec3(buf[idx + 3], buf[idx + 4], buf[idx + 5]);
-        const radius = buf[idx + 6];
-        const startAngle = buf[idx + 7];
-        const endAngle = buf[idx + 8];
-        segs.push(new Arc(center, radius, startAngle, endAngle, normal));
-        idx += 9;
-      }
-    }
-    return new PolyCurve(segs);
-  }
-
-  /**
-   * Chamfer corners of this PolyCurve by cutting each corner with a straight segment.
-   * Returns a new PolyCurve of line segments only.
-   */
-  chamfer(distance: number): PolyCurve {
-    ensureInit();
-    if (this.segments.length < 2) {
-      throw new Error("PolyCurve.chamfer() requires at least 2 segments");
-    }
-
-    const pts: Point[] = [];
-    for (const seg of this.segments) {
-      if (seg instanceof Line) {
-        if (pts.length === 0) pts.push(seg.start);
-        pts.push(seg.end);
-      } else {
-        if (pts.length === 0) pts.push(seg.pointAt(0));
-        pts.push(seg.pointAt(1));
-      }
-    }
-    if (pts.length < 3) {
-      throw new Error("PolyCurve.chamfer() requires at least 3 vertices");
-    }
-
-    const coords = new Float64Array(pts.length * 3);
-    for (let i = 0; i < pts.length; i++) {
-      coords[i * 3] = pts[i].x;
-      coords[i * 3 + 1] = pts[i].y;
-      coords[i * 3 + 2] = pts[i].z;
-    }
-
-    const buf = wasm.chamfer_polycurve(coords, distance);
-    if (buf.length < 1) {
-      throw new Error("PolyCurve.chamfer() failed - WASM returned empty result");
-    }
-    return PolyCurve.fromSegmentData(buf);
-  }
-
-  /**
-   * Offset this PolyCurve by a distance in the given plane.
-   * Extracts vertex points, offsets as a polyline, returns a new PolyCurve of line segments.
-   */
-  offset(distance: number, normal?: Vec3): PolyCurve {
-    ensureInit();
-    if (this.segments.length < 1) {
-      throw new Error("PolyCurve.offset() requires at least 1 segment");
-    }
-
-    const pts: Point[] = [];
-    for (const seg of this.segments) {
-      if (seg instanceof Line) {
-        if (pts.length === 0) pts.push(seg.start);
-        pts.push(seg.end);
-      } else {
-        if (pts.length === 0) pts.push(seg.pointAt(0));
-        pts.push(seg.pointAt(1));
-      }
-    }
-    if (pts.length < 2) {
-      throw new Error("PolyCurve.offset() requires at least 2 vertices");
-    }
-
-    const coords = new Float64Array(pts.length * 3);
-    for (let i = 0; i < pts.length; i++) {
-      coords[i * 3] = pts[i].x;
-      coords[i * 3 + 1] = pts[i].y;
-      coords[i * 3 + 2] = pts[i].z;
-    }
-
-    const nx = normal?.x ?? 0, ny = normal?.y ?? 0, nz = normal?.z ?? 0;
-    const result = wasm.offset_polyline_curve(coords, distance, nx, ny, nz);
-    if (result.length < 6) {
-      throw new Error("PolyCurve.offset() failed - WASM returned insufficient data");
-    }
-
-    // Convert flat coords back to line segments
-    const segs: CurveSegment[] = [];
-    for (let i = 0; i < result.length - 3; i += 3) {
-      const s = new Point(result[i], result[i + 1], result[i + 2]);
-      const e = new Point(result[i + 3], result[i + 4], result[i + 5]);
-      segs.push(new Line(s, e));
-    }
-    return new PolyCurve(segs);
-  }
-
-  /**
-   * Convert to an exact NURBS curve representation via WASM.
-   * Lines become degree-1 NURBS, Arcs become degree-2 rational NURBS.
-   * All segments are degree-elevated to a common degree and joined.
-   */
-  toNurbs(): NurbsCurve {
-    ensureInit();
-    const segData: number[] = [this.segments.length];
-    for (const seg of this.segments) {
-      if (seg instanceof Line) {
-        segData.push(SegmentTypeCode.Line);
-        segData.push(seg.start.x, seg.start.y, seg.start.z);
-        segData.push(seg.end.x, seg.end.y, seg.end.z);
-      } else {
-        // Arc
-        segData.push(SegmentTypeCode.Arc);
-        segData.push(seg.center.x, seg.center.y, seg.center.z);
-        segData.push(seg.normal.x, seg.normal.y, seg.normal.z);
-        segData.push(seg.radius, seg.startAngle, seg.endAngle);
-      }
-    }
-    const buf = wasm.polycurve_to_nurbs(new Float64Array(segData));
-    if (buf.length < 2) throw new Error("Failed to convert PolyCurve to NURBS");
-    return NurbsCurve.fromData(buf);
-  }
-}
+import { ensureInit } from "./engine.js";
+import { Point } from "./Point.js";
+import { Line } from "./Line.js";
+import { Arc } from "./Arc.js";
+import { Vec3 } from "./Vec3.js";
+import { NurbsCurve } from "./NurbsCurve.js";
+import type { Plane } from "./Plane.js";
+import type { CurveSegment, RotationAxis } from "./types.js";
+import { SegmentTypeCode } from "./types.js";
+import { pointsToCoords, coordsToPoints } from "./BufferCodec.js";
+import * as wasm from "../wasm/okgeometrycore.js";
+
+/**
+ * Composite curve made of sequential Line and Arc segments.
+ */
+export class PolyCurve {
+  public readonly segments: CurveSegment[];
+
+  constructor(segments: CurveSegment[]) {
+    this.segments = segments;
+  }
+
+  /** Create a PolyCurve by connecting points with line segments */
+  static byPoints(points: Point[]): PolyCurve {
+    if (points.length < 2) return new PolyCurve([]);
+    const segs: CurveSegment[] = [];
+    for (let i = 0; i < points.length - 1; i++) {
+      segs.push(new Line(points[i], points[i + 1]));
+    }
+    return new PolyCurve(segs);
+  }
+
+  get startPoint(): Point {
+    if (this.segments.length === 0) return Point.ORIGIN;
+    const s = this.segments[0];
+    return s instanceof Line ? s.start : s.pointAt(0);
+  }
+
+  get endPoint(): Point {
+    if (this.segments.length === 0) return Point.ORIGIN;
+    const s = this.segments[this.segments.length - 1];
+    return s instanceof Line ? s.end : s.pointAt(1);
+  }
+
+  /** Returns all constituent curves (Line and Arc segments) in order. */
+  get curves(): CurveSegment[] {
+    return this.segments;
+  }
+
+  /**
+   * Sample all segments into a flat array of points for rendering.
+   * Line segments produce 2 points; Arc segments are sampled with `arcSamples` points.
+   * Consecutive duplicate junction points are removed.
+   */
+  sample(arcSamples = 32): Point[] {
+    const pts: Point[] = [];
+    for (const seg of this.segments) {
+      let segPts: Point[];
+      if (seg instanceof Line) {
+        segPts = [seg.start, seg.end];
+      } else {
+        // Arc: sample into multiple points for smooth rendering
+        segPts = seg.sample(arcSamples);
+      }
+      for (const p of segPts) {
+        // Skip duplicate junction points
+        if (pts.length > 0 && pts[pts.length - 1].equals(p)) continue;
+        pts.push(p);
+      }
+    }
+    return pts;
+  }
+
+  /** Evaluate a point on the curve at normalized parameter t (0 = start, 1 = end). */
+  pointAt(t: number): Point {
+    if (this.segments.length === 0) return Point.ORIGIN;
+    if (t <= 0) return this.startPoint;
+    if (t >= 1) return this.endPoint;
+
+    const lengths = this.segments.map(s => s.length());
+    const total = lengths.reduce((a, b) => a + b, 0);
+    if (total === 0) return this.startPoint;
+
+    let target = t * total;
+    for (let i = 0; i < this.segments.length; i++) {
+      if (target <= lengths[i] || i === this.segments.length - 1) {
+        const localT = lengths[i] > 0 ? target / lengths[i] : 0;
+        return this.segments[i].pointAt(Math.min(localT, 1));
+      }
+      target -= lengths[i];
+    }
+    return this.endPoint;
+  }
+
+  isClosed(eps = 1e-10): boolean {
+    return this.startPoint.equals(this.endPoint, eps);
+  }
+
+  length(): number {
+    return this.segments.reduce((sum, s) => sum + s.length(), 0);
+  }
+
+  rotate(axis: RotationAxis, angle: number): PolyCurve {
+    return new PolyCurve(this.segments.map(s => s.rotate(axis, angle)));
+  }
+
+  translate(offset: Vec3): PolyCurve {
+    return new PolyCurve(this.segments.map(s => s.translate(offset)));
+  }
+
+  projectOntoPlane(plane: Plane, direction?: Vec3, arcSamples = 32): PolyCurve {
+    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
+    const segs: CurveSegment[] = [];
+    for (const s of this.segments) {
+      if (s instanceof Line) {
+        segs.push(new Line(proj(s.start), proj(s.end)));
+      } else {
+        // Arc projects to elliptical arc — approximate with line segments
+        const pts = s.sample(arcSamples);
+        for (let i = 0; i < pts.length - 1; i++) {
+          segs.push(new Line(proj(pts[i]), proj(pts[i + 1])));
+        }
+      }
+    }
+    return new PolyCurve(segs);
+  }
+
+  /**
+   * Fillet corners of this PolyCurve with arcs of the given radius.
+   * Extracts the vertex points, calls WASM fillet_corners, returns a new PolyCurve.
+   */
+  fillet(radius: number, normal?: Vec3): PolyCurve {
+    ensureInit();
+    if (this.segments.length < 2) {
+      throw new Error("PolyCurve.fillet() requires at least 2 segments");
+    }
+
+    // Extract all vertex points from segments
+    const pts: Point[] = [];
+    for (const seg of this.segments) {
+      if (seg instanceof Line) {
+        if (pts.length === 0) pts.push(seg.start);
+        pts.push(seg.end);
+      } else {
+        // Arc: use start and end points
+        if (pts.length === 0) pts.push(seg.pointAt(0));
+        pts.push(seg.pointAt(1));
+      }
+    }
+    if (pts.length < 3) {
+      throw new Error("PolyCurve.fillet() requires at least 3 vertices");
+    }
+
+    const coords = new Float64Array(pts.length * 3);
+    for (let i = 0; i < pts.length; i++) {
+      coords[i * 3] = pts[i].x;
+      coords[i * 3 + 1] = pts[i].y;
+      coords[i * 3 + 2] = pts[i].z;
+    }
+
+    const nx = normal?.x ?? 0, ny = normal?.y ?? 0, nz = normal?.z ?? 0;
+    const buf = wasm.fillet_polycurve(coords, radius, nx, ny, nz);
+    if (buf.length < 1) {
+      throw new Error("PolyCurve.fillet() failed - WASM returned empty result");
+    }
+    return PolyCurve.fromSegmentData(buf);
+  }
+
+  /** Decode a PolyCurve from WASM segment buffer [count, type, ...data, ...] */
+  static fromSegmentData(buf: Float64Array | number[]): PolyCurve {
+    const count = buf[0];
+    const segs: CurveSegment[] = [];
+    let idx = 1;
+    for (let i = 0; i < count; i++) {
+      const type = buf[idx++];
+      if (type === SegmentTypeCode.Line) {
+        // Line: 6 floats
+        const s = new Point(buf[idx], buf[idx + 1], buf[idx + 2]);
+        const e = new Point(buf[idx + 3], buf[idx + 4], buf[idx + 5]);
+        segs.push(new Line(s, e));
+        idx += 6;
+      } else if (type === SegmentTypeCode.Arc) {
+        // Arc: 9 floats
+        const center = new Point(buf[idx], buf[idx + 1], buf[idx + 2]);
+        const normal = new Vec3(buf[idx + 3], buf[idx + 4], buf[idx + 5]);
+        const radius = buf[idx + 6];
+        const startAngle = buf[idx + 7];
+        const endAngle = buf[idx + 8];
+        segs.push(new Arc(center, radius, startAngle, endAngle, normal));
+        idx += 9;
+      }
+    }
+    return new PolyCurve(segs);
+  }
+
+  /**
+   * Chamfer corners of this PolyCurve by cutting each corner with a straight segment.
+   * Returns a new PolyCurve of line segments only.
+   */
+  chamfer(distance: number): PolyCurve {
+    ensureInit();
+    if (this.segments.length < 2) {
+      throw new Error("PolyCurve.chamfer() requires at least 2 segments");
+    }
+
+    const pts: Point[] = [];
+    for (const seg of this.segments) {
+      if (seg instanceof Line) {
+        if (pts.length === 0) pts.push(seg.start);
+        pts.push(seg.end);
+      } else {
+        if (pts.length === 0) pts.push(seg.pointAt(0));
+        pts.push(seg.pointAt(1));
+      }
+    }
+    if (pts.length < 3) {
+      throw new Error("PolyCurve.chamfer() requires at least 3 vertices");
+    }
+
+    const coords = new Float64Array(pts.length * 3);
+    for (let i = 0; i < pts.length; i++) {
+      coords[i * 3] = pts[i].x;
+      coords[i * 3 + 1] = pts[i].y;
+      coords[i * 3 + 2] = pts[i].z;
+    }
+
+    const buf = wasm.chamfer_polycurve(coords, distance);
+    if (buf.length < 1) {
+      throw new Error("PolyCurve.chamfer() failed - WASM returned empty result");
+    }
+    return PolyCurve.fromSegmentData(buf);
+  }
+
+  /**
+   * Offset this PolyCurve by a distance in the given plane.
+   * Extracts vertex points, offsets as a polyline, returns a new PolyCurve of line segments.
+   */
+  offset(distance: number, normal?: Vec3): PolyCurve {
+    ensureInit();
+    if (this.segments.length < 1) {
+      throw new Error("PolyCurve.offset() requires at least 1 segment");
+    }
+
+    const pts: Point[] = [];
+    for (const seg of this.segments) {
+      if (seg instanceof Line) {
+        if (pts.length === 0) pts.push(seg.start);
+        pts.push(seg.end);
+      } else {
+        if (pts.length === 0) pts.push(seg.pointAt(0));
+        pts.push(seg.pointAt(1));
+      }
+    }
+    if (pts.length < 2) {
+      throw new Error("PolyCurve.offset() requires at least 2 vertices");
+    }
+
+    const coords = new Float64Array(pts.length * 3);
+    for (let i = 0; i < pts.length; i++) {
+      coords[i * 3] = pts[i].x;
+      coords[i * 3 + 1] = pts[i].y;
+      coords[i * 3 + 2] = pts[i].z;
+    }
+
+    const nx = normal?.x ?? 0, ny = normal?.y ?? 0, nz = normal?.z ?? 0;
+    const result = wasm.offset_polyline_curve(coords, distance, nx, ny, nz);
+    if (result.length < 6) {
+      throw new Error("PolyCurve.offset() failed - WASM returned insufficient data");
+    }
+
+    // Convert flat coords back to line segments
+    const segs: CurveSegment[] = [];
+    for (let i = 0; i < result.length - 3; i += 3) {
+      const s = new Point(result[i], result[i + 1], result[i + 2]);
+      const e = new Point(result[i + 3], result[i + 4], result[i + 5]);
+      segs.push(new Line(s, e));
+    }
+    return new PolyCurve(segs);
+  }
+
+  /**
+   * Convert to an exact NURBS curve representation via WASM.
+   * Lines become degree-1 NURBS, Arcs become degree-2 rational NURBS.
+   * All segments are degree-elevated to a common degree and joined.
+   */
+  toNurbs(): NurbsCurve {
+    ensureInit();
+    const segData: number[] = [this.segments.length];
+    for (const seg of this.segments) {
+      if (seg instanceof Line) {
+        segData.push(SegmentTypeCode.Line);
+        segData.push(seg.start.x, seg.start.y, seg.start.z);
+        segData.push(seg.end.x, seg.end.y, seg.end.z);
+      } else {
+        // Arc
+        segData.push(SegmentTypeCode.Arc);
+        segData.push(seg.center.x, seg.center.y, seg.center.z);
+        segData.push(seg.normal.x, seg.normal.y, seg.normal.z);
+        segData.push(seg.radius, seg.startAngle, seg.endAngle);
+      }
+    }
+    const buf = wasm.polycurve_to_nurbs(new Float64Array(segData));
+    if (buf.length < 2) throw new Error("Failed to convert PolyCurve to NURBS");
+    return NurbsCurve.fromData(buf);
+  }
+}