okgeometry-api 0.5.0 → 0.5.2

package/src/Point.ts

@@ -0,0 +1,145 @@
+import { Vec3 } from "./Vec3.js";
+import type { Plane } from "./Plane.js";
+import type { RotationAxis } from "./types.js";
+
+/**
+ * Immutable 3D point for representing positions in space.
+ * All operations return new Point instances.
+ */
+export class Point {
+  constructor(
+    public readonly x: number,
+    public readonly y: number,
+    public readonly z: number
+  ) {}
+
+  /**
+   * Compute the distance to another point.
+   * @param other - Target point
+   * @returns Euclidean distance between points
+   */
+  distanceTo(other: Point): number {
+    const dx = this.x - other.x;
+    const dy = this.y - other.y;
+    const dz = this.z - other.z;
+    return Math.sqrt(dx * dx + dy * dy + dz * dz);
+  }
+
+  /**
+   * Convert this point to a vector (from origin).
+   * @returns Vec3 with same coordinates
+   */
+  toVec3(): Vec3 {
+    return new Vec3(this.x, this.y, this.z);
+  }
+
+  /**
+   * Add a vector to this point.
+   * @param v - Vector to add
+   * @returns New point offset by vector
+   */
+  add(v: Vec3): Point {
+    return new Point(this.x + v.x, this.y + v.y, this.z + v.z);
+  }
+
+  /**
+   * Translate this point by an offset vector.
+   * Alias for add().
+   * @param offset - Translation vector
+   * @returns New translated point
+   */
+  translate(offset: Vec3): Point {
+    return this.add(offset);
+  }
+
+  /**
+   * Rotate around an axis by angle in radians using Rodrigues' formula.
+   * @param axis - Vec3 (rotation around origin) or Line (rotation around arbitrary axis)
+   * @param angle - Rotation angle in radians
+   * @returns Rotated point
+   */
+  rotate(axis: RotationAxis, angle: number): Point {
+    if ('start' in axis && 'end' in axis) {
+      const dir = new Vec3(axis.end.x - axis.start.x, axis.end.y - axis.start.y, axis.end.z - axis.start.z);
+      const shifted = new Point(this.x - axis.start.x, this.y - axis.start.y, this.z - axis.start.z);
+      const rotated = shifted.rotate(dir, angle);
+      return new Point(rotated.x + axis.start.x, rotated.y + axis.start.y, rotated.z + axis.start.z);
+    }
+    const len = Math.sqrt(axis.x * axis.x + axis.y * axis.y + axis.z * axis.z);
+    if (len < 1e-15) return this.clone();
+    const k = { x: axis.x / len, y: axis.y / len, z: axis.z / len };
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const dot = k.x * this.x + k.y * this.y + k.z * this.z;
+    const cx = k.y * this.z - k.z * this.y;
+    const cy = k.z * this.x - k.x * this.z;
+    const cz = k.x * this.y - k.y * this.x;
+    return new Point(
+      this.x * cos + cx * sin + k.x * dot * (1 - cos),
+      this.y * cos + cy * sin + k.y * dot * (1 - cos),
+      this.z * cos + cz * sin + k.z * dot * (1 - cos),
+    );
+  }
+
+  /**
+   * Project this point onto a plane.
+   * @param plane - Target plane
+   * @param direction - Optional projection direction (default: perpendicular to plane)
+   * @returns Projected point on plane
+   */
+  projectOntoPlane(plane: Plane, direction?: Vec3): Point {
+    return direction ? plane.projectPointAlongDirection(this, direction) : plane.projectPoint(this);
+  }
+
+  /**
+   * Get the vector from another point to this point.
+   * @param other - Origin point
+   * @returns Vector from other to this
+   */
+  sub(other: Point): Vec3 {
+    return new Vec3(this.x - other.x, this.y - other.y, this.z - other.z);
+  }
+
+  /**
+   * Create a copy of this point.
+   * @returns New point with same coordinates
+   */
+  clone(): Point {
+    return new Point(this.x, this.y, this.z);
+  }
+
+  /**
+   * Check equality with another point within tolerance.
+   * @param other - Point to compare
+   * @param eps - Tolerance (default 1e-10)
+   * @returns True if points are approximately equal
+   */
+  equals(other: Point, eps = 1e-10): boolean {
+    return (
+      Math.abs(this.x - other.x) < eps &&
+      Math.abs(this.y - other.y) < eps &&
+      Math.abs(this.z - other.z) < eps
+    );
+  }
+
+  /**
+   * Convert to array format.
+   * @returns Tuple [x, y, z]
+   */
+  toArray(): [number, number, number] {
+    return [this.x, this.y, this.z];
+  }
+
+  /**
+   * Create a Point from a plain object or JSON.
+   * @param json - Object with x, y, z properties
+   * @returns New Point instance
+   */
+  static fromJSON(json: any): Point {
+    if (json instanceof Point) return json;
+    return new Point(json.x ?? 0, json.y ?? 0, json.z ?? 0);
+  }
+
+  /** Origin point (0, 0, 0) */
+  static readonly ORIGIN = new Point(0, 0, 0);
+}

package/src/PolyCurve.ts

@@ -0,0 +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);
+  }
+}

package/src/Polygon.ts

@@ -0,0 +1,75 @@
+import { Point } from "./Point.js";
+import { Vec3 } from "./Vec3.js";
+import { Polyline } from "./Polyline.js";
+import type { Plane } from "./Plane.js";
+import type { RotationAxis } from "./types.js";
+
+/**
+ * A closed polygon defined by vertices.
+ * Extends Polyline semantics with automatic closure.
+ * If the last point doesn't equal the first, closure is added automatically.
+ */
+export class Polygon extends Polyline {
+  /**
+   * Create a new polygon.
+   * @param points - Vertices of the polygon (will be closed automatically if needed)
+   */
+  constructor(points: Point[]) {
+    // Ensure closure: if last point != first, append first
+    if (points.length >= 3 && !points[0].equals(points[points.length - 1])) {
+      super([...points, points[0]]);
+    } else {
+      super(points);
+    }
+  }
+
+  /**
+   * Number of edges (vertices minus the closing duplicate).
+   */
+  get edgeCount(): number {
+    return Math.max(0, this.points.length - 1);
+  }
+
+  /**
+   * Translate this polygon by an offset vector.
+   * @param offset - Translation vector
+   * @returns New translated polygon
+   */
+  override translate(offset: Vec3): Polygon {
+    const pl = super.translate(offset);
+    return new Polygon(pl.points);
+  }
+
+  /**
+   * Rotate this polygon around an axis.
+   * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
+   * @param angle - Rotation angle in radians
+   * @returns New rotated polygon
+   */
+  override rotate(axis: RotationAxis, angle: number): Polygon {
+    const pl = super.rotate(axis, angle);
+    return new Polygon(pl.points);
+  }
+
+  /**
+   * Offset this polygon perpendicular to its edges.
+   * @param distance - Offset distance
+   * @param normal - Reference normal for determining offset direction
+   * @returns New offset polygon
+   */
+  override offset(distance: number, normal?: Vec3): Polygon {
+    const pl = super.offset(distance, normal);
+    return new Polygon(pl.points);
+  }
+
+  /**
+   * Project this polygon onto a plane.
+   * @param plane - Target plane
+   * @param direction - Optional projection direction (default: perpendicular to plane)
+   * @returns New projected polygon
+   */
+  override projectOntoPlane(plane: Plane, direction?: Vec3): Polygon {
+    const pl = super.projectOntoPlane(plane, direction);
+    return new Polygon(pl.points);
+  }
+}

package/src/Polyline.ts

@@ -0,0 +1,153 @@
+import { ensureInit } from "./engine.js";
+import { Point } from "./Point.js";
+import { Vec3 } from "./Vec3.js";
+import { Mesh } from "./Mesh.js";
+import { Line } from "./Line.js";
+import { PolyCurve } from "./PolyCurve.js";
+import type { Plane } from "./Plane.js";
+import type { RotationAxis } from "./types.js";
+import { pointsToCoords, coordsToPoints } from "./BufferCodec.js";
+import * as wasm from "../wasm/okgeometrycore_bg.js";
+
+/**
+ * Open or closed polyline defined by a sequence of points.
+ * Supports length, evaluation, transformation, and extrusion operations.
+ */
+export class Polyline {
+  public readonly points: Point[];
+
+  constructor(points: Point[]) {
+    this.points = points;
+  }
+
+  /**
+   * Get the total length of this polyline.
+   * @returns Sum of segment lengths
+   */
+  length(): number {
+    ensureInit();
+    return wasm.polyline_length(this.toCoords());
+  }
+
+  /**
+   * Evaluate a point on the polyline at normalized parameter t.
+   * @param t - Parameter in [0, 1] (0 = first point, 1 = last point)
+   * @returns Point on polyline at parameter t
+   */
+  pointAt(t: number): Point {
+    ensureInit();
+    const r = wasm.polyline_point_at(this.toCoords(), t);
+    return new Point(r[0], r[1], r[2]);
+  }
+
+  /**
+   * Check if this polyline is closed.
+   * @param eps - Tolerance for comparing first and last points
+   * @returns True if first and last points coincide
+   */
+  isClosed(eps = 1e-10): boolean {
+    if (this.points.length < 2) return false;
+    return this.points[0].equals(this.points[this.points.length - 1], eps);
+  }
+
+  /**
+   * Extrude this polyline along a direction vector.
+   * @param direction - Extrusion direction and magnitude
+   * @param segments - Number of segments along extrusion (default 1)
+   * @param caps - Whether to cap the ends (default false)
+   * @returns Mesh representing the extruded surface
+   */
+  extrude(direction: Vec3, segments = 1, caps = false): Mesh {
+    ensureInit();
+    const buf = wasm.extrude_polyline(
+      this.toCoords(),
+      direction.x, direction.y, direction.z,
+      segments, caps
+    );
+    return Mesh.fromBuffer(buf);
+  }
+
+  /**
+   * Translate this polyline by an offset vector.
+   * @param offset - Translation vector
+   * @returns New translated polyline
+   */
+  translate(offset: Vec3): Polyline {
+    return new Polyline(this.points.map(p => p.add(offset)));
+  }
+
+  /**
+   * Rotate this polyline around an axis.
+   * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
+   * @param angle - Rotation angle in radians
+   * @returns New rotated polyline
+   */
+  rotate(axis: RotationAxis, angle: number): Polyline {
+    return new Polyline(this.points.map(p => p.rotate(axis, angle)));
+  }
+
+  /**
+   * Offset this polyline perpendicular to its segments.
+   * @param distance - Offset distance
+   * @param normal - Reference normal for determining offset direction
+   * @returns New offset polyline
+   */
+  offset(distance: number, normal?: Vec3): Polyline {
+    ensureInit();
+    const nx = normal?.x ?? 0, ny = normal?.y ?? 0, nz = normal?.z ?? 0;
+    const result = wasm.offset_polyline_curve(this.toCoords(), distance, nx, ny, nz);
+    return new Polyline(coordsToPoints(result));
+  }
+
+  /**
+   * Project this polyline onto a plane.
+   * @param plane - Target plane
+   * @param direction - Optional projection direction (default: perpendicular to plane)
+   * @returns New projected polyline
+   */
+  projectOntoPlane(plane: Plane, direction?: Vec3): Polyline {
+    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
+    return new Polyline(this.points.map(proj));
+  }
+
+  /**
+   * Fillet corners of this polyline with arcs of the given radius.
+   * @param radius - Fillet radius
+   * @param normal - Reference normal for arc orientation (auto-detected if not provided)
+   * @returns PolyCurve with Line and Arc segments
+   */
+  fillet(radius: number, normal?: Vec3): PolyCurve {
+    ensureInit();
+    if (this.points.length < 3) {
+      throw new Error("Polyline.fillet() requires at least 3 points");
+    }
+
+    const nx = normal?.x ?? 0, ny = normal?.y ?? 0, nz = normal?.z ?? 0;
+    const buf = wasm.fillet_polycurve(this.toCoords(), radius, nx, ny, nz);
+    if (buf.length < 1) {
+      throw new Error("Polyline.fillet() failed - WASM returned empty result");
+    }
+
+    return PolyCurve.fromSegmentData(buf);
+  }
+
+  /**
+   * Convert this polyline to a PolyCurve (line segments only).
+   * @returns PolyCurve with Line segments connecting consecutive points
+   */
+  toPolyCurve(): PolyCurve {
+    const segs: Line[] = [];
+    for (let i = 0; i < this.points.length - 1; i++) {
+      segs.push(new Line(this.points[i], this.points[i + 1]));
+    }
+    return new PolyCurve(segs);
+  }
+
+  /**
+   * Convert points to flat coordinate array for WASM.
+   * @returns Float64Array [x1,y1,z1, x2,y2,z2, ...]
+   */
+  private toCoords(): Float64Array {
+    return pointsToCoords(this.points);
+  }
+}