plotboilerplate 1.28.1 → 1.30.0

package/src/ts/Circle.ts

@@ -14,7 +14,16 @@
  * @modified 2022-08-23 Added the `closestPoint` function.
  * @modified 2025-04-09 Added the `Circle.move(amount: XYCoords)` method.
  * @modified 2025-04-16 Class `Circle` now implements interface `Intersectable`.
- * @version  1.5.0
+ * @modified 2026-06-10 Adding the utility function `Circle.circleUtils.containsPoint`.
+ * @modified 2026-06-10 Adding the `Circle.clone` method.
+ * @modified 2026-01-13 Adding helper function `Circle.circleUtils.containsPoint` and refactored the member method `containsPoint`.
+ * @modified 2026-07-03 Adding the optional `epsilon` parameter to the `Circle.containsCircle` method.
+ * @modified 2026-07-03 Fixing the `Circle.clone` method; the center had not been cloned at all, this was fixed.
+ * @modified 2026-07-08 Adding the `Circle.setRadius` method (for chaining).
+ * @mofified 2026-07-31 Adding the `radicalAxis(Circle)` method. Added the `Circle.circleUtils.createRadicalAxisHelperCircle` and `.circleDistance` helper methods.
+ * @modified 2026-08-03 Adding `Circle.tangentsFromPoint`.
+ * @modified 2026-08-16 Adding the `Circle.sectorAngleByArcLength` method and the `Circle.circleUtils.sectorAngleByArcLength` helper method.
+ * @version  1.8.0
  **/
 
 import { Bounds } from "./Bounds";
@@ -23,8 +32,15 @@ import { UIDGenerator } from "./UIDGenerator";
 import { Vector } from "./Vector";
 import { VertTuple } from "./VertTuple";
 import { Vertex } from "./Vertex";
+import { geomutils } from "./geomutils";
 import { IBounded, Intersectable, SVGSerializable, UID, XYCoords } from "./interfaces";
 
+export interface ICircle {
+  center: XYCoords;
+  radius: number;
+  radius_squared?: number;
+}
+
 /**
  * @classdesc A simple circle: center point and radius.
  *
@@ -36,7 +52,7 @@ import { IBounded, Intersectable, SVGSerializable, UID, XYCoords } from "./inter
  * @requires UID
  * @requires UIDGenerator
  **/
-export class Circle implements IBounded, Intersectable, SVGSerializable {
+export class Circle implements IBounded, ICircle, Intersectable, SVGSerializable {
   /**
    * Required to generate proper CSS classes and other class related IDs.
    **/
@@ -88,6 +104,21 @@ export class Circle implements IBounded, Intersectable, SVGSerializable {
     this.radius = radius;
   }
 
+  /**
+   * Set the radius of this circle.
+   * The method is meant for chaining, you may also alter the `radius` attribute directly.
+   *
+   * @method setRadius
+   * @param {number} radius - The amount to move.
+   * @instance
+   * @memberof Circle
+   * @return {Circle} this for chaining
+   **/
+  setRadius(radius: number): Circle {
+    this.radius = radius;
+    return this;
+  }
+
   /**
    * Move the circle by the given amount.
    *
@@ -112,7 +143,8 @@ export class Circle implements IBounded, Intersectable, SVGSerializable {
    * @return {boolean} `true` if the given point is inside this circle.
    */
   containsPoint(point: XYCoords): boolean {
-    return this.center.distance(point) < this.radius;
+    // return this.center.distance(point) < this.radius;//
+    return Circle.circleUtils.containsPoint(this.center, this.radius, point);
   }
 
   /**
@@ -124,8 +156,12 @@ export class Circle implements IBounded, Intersectable, SVGSerializable {
    * @memberof Circle
    * @return {boolean} `true` if any only if the given circle is completely inside this circle.
    */
-  containsCircle(circle: Circle): boolean {
-    return this.center.distance(circle.center) + circle.radius < this.radius;
+  containsCircle(circle: Circle, epsilon?: number): boolean {
+    if (typeof epsilon === "undefined" || Number.isNaN(epsilon)) {
+      return this.center.distance(circle.center) + circle.radius < this.radius;
+    } else {
+      return this.center.distance(circle.center) + circle.radius < this.radius + Math.abs(epsilon);
+    }
   }
 
   /**
@@ -347,6 +383,43 @@ export class Circle implements IBounded, Intersectable, SVGSerializable {
   }
   //--- END --- Implement interface `Intersectable`
 
+  /**
+   * Calculate the radical axis of this and a different circle.
+   * The two circles must not be co-centric.
+   *
+   * See this article for details:
+   *    https://www.cut-the-knot.org/Curriculum/Geometry/GeoGebra/RadicalAxes.shtml
+   *
+   * @method radicalAxis
+   * @instance
+   * @memberof Circle
+   * @param {Circle} circleB - The second circle to calculated the radical axis for.
+   * @return {Line} A line defining the radical axis of the two circles.
+   **/
+  radicalAxis(circleB: Circle): Line {
+    var helperCircle = Circle.circleUtils.createRadicalAxisHelperCircle(this, circleB);
+    var intersectionLineA = this.circleIntersection(helperCircle);
+    var intersectionLineB = circleB.circleIntersection(helperCircle);
+    var intersection = this.circleIntersection(circleB);
+
+    if (!intersectionLineA || !intersectionLineB) {
+      console.error("Critical error: none of the two intersections must be null.");
+      return intersection; // Fallback
+    }
+    var lineA = new Line(intersectionLineA.a, intersectionLineA.b);
+    var lineB = new Line(intersectionLineB.a, intersectionLineB.b);
+    var firstRadicalAxisPoint = lineA.intersection(lineB);
+    var centerConnectLine = new Line(this.center, circleB.center);
+    var secondRadicalAxisPoint = centerConnectLine.getClosestPoint(firstRadicalAxisPoint);
+    // Create a mirrored version of the second radical axis point so both are located
+    // symmetrical from the circle connect point.
+    // (currently the second point is located ON the connect line)
+    var secondRadicalAxisPoint_mirrored = secondRadicalAxisPoint.clone().scale(2.0, firstRadicalAxisPoint);
+
+    var radicalAxis = new Line(firstRadicalAxisPoint, secondRadicalAxisPoint_mirrored);
+    return intersection && intersection.length() > radicalAxis.length() ? intersection : radicalAxis;
+  }
+
   /**
    * Calculate the closest point on the outline of this circle to the given point.
    *
@@ -370,6 +443,87 @@ export class Circle implements IBounded, Intersectable, SVGSerializable {
     }
   }
 
+  /**
+   * Get the two tangent vectors for the given point.
+   * If the point is on or in the circle then null is returned.
+   *
+   * @method tangentsFromPoint
+   * @instance
+   * @memberof Circle
+   * @param {Vertex} vert - The point to find the two tangents for.
+   * @return {[Vector,Vector]} The two tangent vector
+   **/
+  tangentsFromPoint(vert: Vertex): [Vector, Vector] {
+    // Inspired by
+    //   https://www.omnicalculator.com/math/tangent-circle
+    const centerDistance: number = this.center.distance(vert);
+    const tangentLength: number = Math.sqrt(centerDistance * centerDistance - this.radius * this.radius);
+    // console.log("this.radius ", this.radius, "centerDistance", centerDistance, "tangentLength", tangentLength);
+    if (Number.isNaN(tangentLength)) {
+      // vertex is inside circle
+      console.log("tangentLength is NaN", tangentLength);
+      return null;
+    }
+
+    const helperCircle = new Circle(vert, tangentLength);
+    const intersection = this.circleIntersection(helperCircle);
+    if (!intersection) {
+      // No intersection (vertex is inside circle)
+      return null;
+    }
+
+    return [new Vector(intersection.a, vert), new Vector(intersection.b, vert)];
+  }
+
+  /**
+   * Calculate inner sector angle for this circle and a given circle arc length.
+   *
+   * @param {number} sectorArcLength - The desired arc length (in units).
+   * @returns The sector's inner angle (in radians).
+   */
+  sectorAngleByArcLength(sectorArcLength: number) {
+    return Circle.circleUtils.sectorAngleByArcLength(sectorArcLength, this.radius);
+  }
+
+  /**
+   * Create a deep copy of this circle.
+   *
+   * @method clone
+   * @return {Circle} A new circle, an exact copy of this one.
+   * @instance
+   * @memberof Circle
+   **/
+  clone(): Circle {
+    return new Circle(this.center.clone(), this.radius);
+  }
+
+  static fromICircle(obj: ICircle): Circle {
+    return new Circle(new Vertex(obj.center), obj.radius);
+  }
+
+  // static fromObject(obj: object): Circle {
+  //   if (!obj) {
+  //     return null;
+  //   }
+  //   if (typeof obj !== "object") {
+  //     return null;
+  //   }
+  //   if (!obj.hasOwnProperty("center") || typeof (obj as any).center != "object") {
+  //     return null;
+  //   }
+  //   if (!obj.hasOwnProperty("radius") || typeof !(obj as any).radius != "number") {
+  //     return null;
+  //   }
+  //   var center = (obj as any).center;
+  //   if (!center.hasOwnProperty("x") || typeof (center as any).x != "number") {
+  //     return null;
+  //   }
+  //   if (!center.hasOwnProperty("y") || typeof (center as any).y != "number") {
+  //     return null;
+  //   }
+  //   return new Circle(new Vertex(center), (obj as any).radius);
+  // }
+
   /**
    * This function should invalidate any installed listeners and invalidate this object.
    * After calling this function the object might not hold valid data any more and
@@ -385,6 +539,47 @@ export class Circle implements IBounded, Intersectable, SVGSerializable {
       /* return new Vertex( Math.sin(angle) * radius,
 			       Math.cos(angle) * radius ); */
       return new Vertex(Math.cos(angle) * radius, Math.sin(angle) * radius);
+    },
+
+    containsPoint: (circleCenter: XYCoords, circleRadius: number, point: XYCoords): boolean => {
+      // TODO: cleanup
+      // return (
+      //   (circle.center.x - point.x) * (circle.center.x - point.x) + (circle.center.y - point.y) * (circle.center.y - point.y) <=
+      //   circle.radius * circle.radius
+      // );
+      return geomutils.dist4(point.x, point.y, circleCenter.x, circleCenter.y) < circleRadius;
+    },
+
+    createRadicalAxisHelperCircle: (circleA: Circle, circleB: Circle): Circle => {
+      // We need to create a helper circle that intersects BOTH other circles,
+      // each in TWO points.
+      var circleConnectLine = new Vector(circleA.center.clone(), circleB.center);
+      circleConnectLine.a.set(circleConnectLine.vertAt(0.5));
+      // Get the perpendicular by half the circle distance.
+      var bisector = circleConnectLine.perp();
+      var bisectorLength = Math.max(circleA.radius, circleB.radius, bisector.length());
+      bisector.setLength(bisectorLength);
+      return new Circle(bisector.b, bisector.b.distance(circleA.center));
+    },
+
+    /**
+     * Calculate the outer distance between two circles. If the circles touch then the
+     * distance is 0.0.
+     * If the circles intersect then the distance in negative.
+     */
+    circleDistance: (circleA: Circle, circleB: Circle): number => {
+      return circleA.center.distance(circleB.center) - circleA.radius - circleB.radius;
+    },
+
+    /**
+     * Calculate the inner sector angle for a given circle arc length and radius.
+     *
+     * @param {number} sectorArcLength - The desired arc length.
+     * @param {number} circleRadius - The circle's radius.
+     * @returns The sector angle in radians.
+     */
+    sectorAngleByArcLength: (sectorArcLength: number, circleRadius: number) => {
+      return sectorArcLength / circleRadius;
     }
   };
 } // END class

package/src/ts/CubicBezierCurve.ts

@@ -32,8 +32,9 @@
  * @modified 2025-04-18 Added evaluation method for cubic Bézier curves `CubicBezierCurve.utils.evaluateT`.
  * @modified 2025-04-18 Refactored method `CubicBezierCurve.getPointAt` to use `evaluateT`.
  * @modified 2025-04-18 Fixed the `CubicBezierCurve.getBounds` method: now returning the real bounding box. Before it was an approximated one.
- * @modified 2025-ß4-18 Added helper methods for bounding box calculation `CubucBezierCurve.util.cubicPolyMinMax` and `cubicPoly`.
- * @version 2.9.0
+ * @modified 2025-04-18 Added helper methods for bounding box calculation `CubucBezierCurve.util.cubicPolyMinMax` and `cubicPoly`.
+ * @modified 2026-09-09 Adding methods `CubicBezierCurve.trimStartEnd` and `CubicBezierCurve.trimStartEndAt`.
+ * @version 2.10.0
  *
  * @file CubicBezierCurve
  * @public
@@ -401,30 +402,30 @@ export class CubicBezierCurve implements IBounded, Intersectable, PathSegment {
     // Thanks to Richard "RM" for the Bézier bounds calculatin
     //    https://jsfiddle.net/SalixAlba/QQnvm/4/
 
-      const xMinMax = CubicBezierCurve.utils.cubicPolyMinMax(
-        this.startPoint.x,
-        this.startControlPoint.x,
-        this.endControlPoint.x,
-        this.endPoint.x
-      );
-      const xl = xMinMax.min;
-      const xh = xMinMax.max;
-
-      const yMinMax = CubicBezierCurve.utils.cubicPolyMinMax(
-        this.startPoint.y,
-        this.startControlPoint.y,
-        this.endControlPoint.y,
-        this.endPoint.y
-      );
-      const yl = yMinMax.min;
-      const yh = yMinMax.max;
-
-      return Bounds.computeFromVertices([
-        { x: xl, y: yl },
-        { x: xl, y: yh },
-        { x: xh, y: yh },
-        { x: xh, y: yl }
-      ]);
+    const xMinMax = CubicBezierCurve.utils.cubicPolyMinMax(
+      this.startPoint.x,
+      this.startControlPoint.x,
+      this.endControlPoint.x,
+      this.endPoint.x
+    );
+    const xl = xMinMax.min;
+    const xh = xMinMax.max;
+
+    const yMinMax = CubicBezierCurve.utils.cubicPolyMinMax(
+      this.startPoint.y,
+      this.startControlPoint.y,
+      this.endControlPoint.y,
+      this.endPoint.y
+    );
+    const yl = yMinMax.min;
+    const yh = yMinMax.max;
+
+    return Bounds.computeFromVertices([
+      { x: xl, y: yl },
+      { x: xl, y: yh },
+      { x: xh, y: yh },
+      { x: xh, y: yl }
+    ]);
   }
   //--- END --- Implement interface `IBounded`
 
@@ -526,8 +527,20 @@ export class CubicBezierCurve implements IBounded, Intersectable, PathSegment {
     //   this.startControlPoint.y * 3 * t * Math.pow(1.0 - t, 2) +
     //   this.endControlPoint.y * 3 * Math.pow(t, 2) * (1.0 - t) +
     //   this.endPoint.y * Math.pow(t, 3);
-    const x: number = CubicBezierCurve.utils.evaluateT(this.startPoint.x, this.startControlPoint.x, this.endControlPoint.x, this.endPoint.x, t);
-    const y: number = CubicBezierCurve.utils.evaluateT(this.startPoint.y, this.startControlPoint.y, this.endControlPoint.y, this.endPoint.y, t);
+    const x: number = CubicBezierCurve.utils.evaluateT(
+      this.startPoint.x,
+      this.startControlPoint.x,
+      this.endControlPoint.x,
+      this.endPoint.x,
+      t
+    );
+    const y: number = CubicBezierCurve.utils.evaluateT(
+      this.startPoint.y,
+      this.startControlPoint.y,
+      this.endControlPoint.y,
+      this.endPoint.y,
+      t
+    );
     return new Vertex(x, y);
   }
 
@@ -611,6 +624,7 @@ export class CubicBezierCurve implements IBounded, Intersectable, PathSegment {
     this.endControlPoint.set(subCurbePoints[3]);
     this.updateArcLengths();
     return this;
+    // return this.trimStartEndAt(t, null);
   }
 
   /**
@@ -648,8 +662,88 @@ export class CubicBezierCurve implements IBounded, Intersectable, PathSegment {
     this.endControlPoint.set(subCurbePoints[3]);
     this.updateArcLengths();
     return this;
+    // return this.trimStartEndAt(null, t);
   }
 
+  /**
+   * Trim off a start and end section of this curve. The position parameters `uStart` and `uEnd` are the absolute positions in [0..arcLength].
+   * The remaining curve will be the one in the bounds `[uStart,uEnd]` (so `[0.0,uStart]` and `[uEnd,1.0]` are cut off).
+   *
+   * Parameters out of bounds (< 0.0 or > arcLength) are ignored.
+   * If `uEnd` is smaller than `uStart` then a curve with length zero (0) at `uStart` is returned.
+   *
+   * @method trimStartEndAt
+   * @instance
+   * @memberof CubicBezierCurve
+   * @param {number} tStart - The relative position parameter where to cut off the head curve.
+   * @param {number} tEnd - The relative position parameter where to cut off the tail curve.
+   * @returns {CubicBezierCurve} `this` for chanining.
+   */
+
+  trimStartEnd(uStart: number, uEnd: number): CubicBezierCurve {
+    return this.trimStartEndAt(this.convertU2T(uStart), this.convertU2T(uEnd));
+  }
+
+  /**
+   * Trim off a start and end section of this curve. The position parameters `tStart` and `tEnd` are the relative positions in [0..1].
+   * The remaining curve will be the one in the bounds `[tStart,tEnd]` (so `[0.0,tStart]` and `[tEnd,1.0]` are cut off).
+   *
+   * Parameters out of bounds (< 0.0 or > 1.0) are ignored.
+   * If `tEnd` is smaller than `tStart` then a curve with length zero (0) at `tStart` is returned.
+   *
+   * @method trimStartEndAt
+   * @instance
+   * @memberof CubicBezierCurve
+   * @param {number} tStart - The relative position parameter where to cut off the head curve.
+   * @param {number} tEnd - The relative position parameter where to cut off the tail curve.
+   * @returns {CubicBezierCurve} `this` for chanining.
+   */
+
+  trimStartEndAt(tStart: number, tEnd: number): CubicBezierCurve {
+    const cleanTrimStart = Math.min(Math.max(0.0, tStart), 1.0);
+    const cleanTrimEnd = Math.min(Math.max(cleanTrimStart, tEnd), 1.0);
+    this.trimStartAt(cleanTrimStart);
+    const relativeTrimEnd = (cleanTrimEnd - cleanTrimStart) / (1.0 - cleanTrimStart);
+    this.trimEndAt(relativeTrimEnd);
+    return this;
+  }
+
+  // __trimStartEndAt(tStart: number, tEnd: number): CubicBezierCurve {
+  //   var finalCurvePoints = [
+  //     this.startPoint.clone(),
+  //     this.endPoint.clone(),
+  //     this.startControlPoint.clone(),
+  //     this.endControlPoint.clone()
+  //   ];
+  //   if (typeof tStart === "number" && !Number.isNaN(tStart)) {
+  //     const subCurvePointsStart = CubicBezierCurve.utils.getSubCurvePointsAt(this, tStart, 1.0);
+  //     finalCurvePoints[0].set(subCurvePointsStart[0]);
+  //     finalCurvePoints[2].set(subCurvePointsStart[2]);
+  //     // this.startPoint.set(subCurvePointsStart[0]);
+  //     // this.startControlPoint.set(subCurvePointsStart[2]);
+  //     // this.endPoint.set(subCurvePointsStart[1]);
+  //     // this.endControlPoint.set(subCurvePointsStart[3]);
+  //   }
+
+  //   if (typeof tEnd === "number" && !Number.isNaN(tEnd)) {
+  //     const subCurvePointsEnd = CubicBezierCurve.utils.getSubCurvePointsAt(this, 0.0, tEnd);
+  //     // this.startPoint.set(subCurvePointsEnd[0]);
+  //     // this.startControlPoint.set(subCurvePointsEnd[2]);
+  //     // this.endPoint.set(subCurvePointsEnd[1]);
+  //     // this.endControlPoint.set(subCurvePointsEnd[3]);
+  //     finalCurvePoints[1].set(subCurvePointsEnd[1]);
+  //     finalCurvePoints[3].set(subCurvePointsEnd[3]);
+  //   }
+
+  //   this.startPoint.set(finalCurvePoints[0]);
+  //   this.endPoint.set(finalCurvePoints[1]);
+  //   this.startControlPoint.set(finalCurvePoints[2]);
+  //   this.endControlPoint.set(finalCurvePoints[3]);
+
+  //   this.updateArcLengths();
+  //   return this;
+  // }
+
   /**
    * Get a sub curve at the given start end end positions (values on the curve's length, between 0 and curve.arcLength).
    *
@@ -1027,15 +1121,13 @@ export class CubicBezierCurve implements IBounded, Intersectable, PathSegment {
    * Helper utils.
    */
   public static utils = {
-
-    evaluateT: (p0:number, p1:number, p2:number, p3:number, t:number) : number => {
-      return p0 * Math.pow(1.0 - t, 3) +
-        p1 * 3 * t * Math.pow(1.0 - t, 2) +
-        p2 * 3 * Math.pow(t, 2) * (1.0 - t) +
-        p3 * Math.pow(t, 3);
+    evaluateT: (p0: number, p1: number, p2: number, p3: number, t: number): number => {
+      return (
+        p0 * Math.pow(1.0 - t, 3) + p1 * 3 * t * Math.pow(1.0 - t, 2) + p2 * 3 * Math.pow(t, 2) * (1.0 - t) + p3 * Math.pow(t, 3)
+      );
     },
 
-    cubicPolyMinMax: (p0:number, p1:number, p2:number, p3:number) : { min: number, max: number }=> {
+    cubicPolyMinMax: (p0: number, p1: number, p2: number, p3: number): { min: number; max: number } => {
       // var polyX = CubicBezierCurve.utils.cubicPoly2(
       //   p0, // P[0].X, // bezierCurve.startPoint.x,
       //   p1, // P[1].X, // bezierCurve.startControlPoint.x,
@@ -1048,7 +1140,6 @@ export class CubicBezierCurve implements IBounded, Intersectable, PathSegment {
       // var c = polyX.c;
       // var disc = polyX.b * polyX.b - 4 * polyX.a * polyX.c;
 
-
       var polyX = CubicBezierCurve.utils.cubicPoly(
         p0, // P[0].X, // bezierCurve.startPoint.x,
         p1, // P[1].X, // bezierCurve.startControlPoint.x,
@@ -1062,7 +1153,6 @@ export class CubicBezierCurve implements IBounded, Intersectable, PathSegment {
       // var disc = b * b - 4 * a * c;
       var disc = polyX[1] * polyX[1] - 4 * polyX[0] * polyX[2];
 
-
       // var polyX = CubicBezierCurve.utils.bezierCoeffs(p3,p2,p1,p0);
       // var a = polyX[0]; //polyX.a;
       // var b = polyX[1]; // .b;
@@ -1111,7 +1201,7 @@ export class CubicBezierCurve implements IBounded, Intersectable, PathSegment {
      * @param {number} tEnd – The end offset if the desired cub curve (must be in [0..1]).
      * @instance
      * @memberof CubicBezierCurve
-     * @return {CubicBezierCurve} The sub curve as a new curve.
+     * @return {[Vertex, Vertex, Vertex, Vertex]} The sub curve as curve vertices.
      **/
     getSubCurvePointsAt: (curve: CubicBezierCurve, tStart: number, tEnd: number): [Vertex, Vertex, Vertex, Vertex] => {
       const startVec: Vector = new Vector(curve.getPointAt(tStart), curve.getTangentAt(tStart));
@@ -1196,8 +1286,8 @@ export class CubicBezierCurve implements IBounded, Intersectable, PathSegment {
      * @param {number} p3 - The end point coordinate.
      * @returns {[number,number,number,number]}
      */
-    bezierCoeffs: (p0: number, p1: number, p2: number, p3: number): [number,number,number,number] => {
-      const coeffs : [number,number,number,number]  = [NaN,NaN,NaN,NaN]; //Array(4);
+    bezierCoeffs: (p0: number, p1: number, p2: number, p3: number): [number, number, number, number] => {
+      const coeffs: [number, number, number, number] = [NaN, NaN, NaN, NaN]; //Array(4);
       coeffs[0] = -p0 + 3 * p1 + -3 * p2 + p3;
       coeffs[1] = 3 * p0 - 6 * p1 + 3 * p2;
       coeffs[2] = -3 * p0 + 3 * p1;
@@ -1207,22 +1297,17 @@ export class CubicBezierCurve implements IBounded, Intersectable, PathSegment {
 
     /**
      * Calculate the cubic polynomial coefficients used to find the bounding box.
-     * 
+     *
      * @param {number} p0 - The start point coordinate.
      * @param {number} p1 - The start control point coordinate.
      * @param {number} p2 - The end control point coordinate.
      * @param {number} p3 - The end point coordinate.
      * @returns {[number,number,number]}
      */
-    cubicPoly: (p0:number, p1:number, p2:number, p3:number) : [number,number,number] => {
-      return [
-         3 * p3 - 9 * p2 + 9 * p1 - 3 * p0,
-         6 * p0 - 12 * p1 + 6 * p2,
-         3 * p1 - 3 * p0
-      ]
+    cubicPoly: (p0: number, p1: number, p2: number, p3: number): [number, number, number] => {
+      return [3 * p3 - 9 * p2 + 9 * p1 - 3 * p0, 6 * p0 - 12 * p1 + 6 * p2, 3 * p1 - 3 * p0];
     },
 
-
     /**
      * sign of number, but is division safe: no zero returned :)
      */

package/src/ts/Line.ts

@@ -18,7 +18,8 @@
  * @modified 2023-09-25 Changed param type of `intersection()` from Line to VertTuple.
  * @modified 2025-04-15 Class `Line` now implements interface `Intersectable`.
  * @modified 2025-04-16 Class `Line` now implements interface `IBounded`.
- * @version  2.4.0
+ * @modified 2026-08-16 Adding methods `Line.trimStart` and `Line.trimEnd`. Adding methods `Line.trimStartAt` and `Line.trimEndAt`.
+ * @version  2.5.0
  *
  * @file Line
  * @public
@@ -165,6 +166,88 @@ export class Line extends VertTuple<Line> implements IBounded, Intersectable, Pa
   }
   //--- END Implement PathSegment ---
 
+  /**
+   * Trim this line segment from the start point by the given amount.
+   * The amount must be positive and should be withing the segment's length. If the amount exceeds the segment's length
+   * then the length of the resulting line will be zero (0.0).
+   *
+   * @method trimStart
+   * @memberof Line
+   * @param {number} amount - The positive amount to trim the line from the start point `a`.
+   * @returns {Line} This for chaining, with updated point `a`.
+   */
+  trimStart(amount: number) {
+    // Calculate the relative position `t` on this line.
+    var t: number = amount / this.length();
+    // `t` should be inside 0..1 – otherwise the amount was too large or negative.
+    if (t < 0.0) {
+      return this;
+    }
+    if (t > 1.0) {
+      // Set the line to length zero (endpoint only)
+      this.a = this.b.clone();
+      return this;
+    }
+    this.a = this.vertAt(t);
+    return this;
+  }
+
+  /**
+   * Trim this line segment from the start point by the given relative amount.
+   * The amount must be positive and should be within 0.0 and 1.0. If the amount exceeds the segment's length
+   * then the length of the resulting line will be zero (0.0).
+   *
+   * @method trimStartAt
+   * @memberof Line
+   * @param {number} amount - The positive amount to trim the line from the start point `a`.
+   * @returns {Line} This for chaining, with updated point `a`.
+   */
+  trimStartAt(relativeAmount: number) {
+    // Calculate the relative position `t` on this line.
+    return this.trimStart(relativeAmount * this.length());
+  }
+
+  /**
+   * Trim this line segment from the end point by the given amount.
+   * The amount must be positive and should be withing the segment's length. If the amount exceeds the segment's length
+   * then the length of the resulting line will be zero (0.0).
+   *
+   * @method trimEnd
+   * @memberof Line
+   * @param {number} amount - The positive amount to trim the line from the end point `b`.
+   * @returns {Line} This for chaining, with updated point `b`.
+   */
+  trimEnd(amount: number) {
+    // Calculate the relative position `t` on this line.
+    var t: number = 1.0 - amount / this.length();
+    // `t` should be inside 0..1 – otherwise the amount was too large or negative.
+    if (t < 0.0) {
+      return this;
+    }
+    if (t > 1.0) {
+      // Set the line to length zero (endpoint only)
+      this.b = this.a.clone();
+      return this;
+    }
+    this.b = this.vertAt(t);
+    return this;
+  }
+
+  /**
+   * Trim this line segment from the end point by the given relative amount.
+   * The amount must be positive and should be within 0.0 and 1.0. If the amount exceeds the segment's length
+   * then the length of the resulting line will be zero (0.0).
+   *
+   * @method trimEndAt
+   * @memberof Line
+   * @param {number} amount - The positive amount to trim the line from the start point `a`.
+   * @returns {Line} This for chaining, with updated point `a`.
+   */
+  trimEndAt(relativeAmount: number) {
+    // Calculate the relative position `t` on this line.
+    return this.trimEnd(relativeAmount * this.length());
+  }
+
   //--- BEGIN --- Implement interface `Intersectable`
   /**
    * Get all line intersections with this polygon.