plotboilerplate 1.23.3 → 1.25.0

package/src/ts/VEllipse.ts

@@ -15,7 +15,11 @@
  * @modified 2021-03-19 Added the `VEllipse.rotate` function.
  * @modified 2022-02-02 Added the `destroy` method.
  * @modified 2022-02-02 Cleared the `VEllipse.toSVGString` function (deprecated). Use `drawutilssvg` instead.
- * @version  1.3.0
+ * @modified 2025-03-31 ATTENTION: modified the winding direction of the `tangentAt` method to match with the Circle method. This is a breaking change!
+ * @modified 2025-03-31 Adding the `VEllipse.move(amount: XYCoords)` method.
+ * @modified 2025-04-19 Adding the `VEllipse.getBounds()` method.
+ * @modified 2025-04-24 Adding the `VEllipse.getExtremePoints()` method for calculating minima and maxima.
+ * @version  1.4.0
  *
  * @file VEllipse
  * @fileoverview Ellipses with a center and an x- and a y-axis (stored as a vertex).
@@ -25,8 +29,11 @@ import { Line } from "./Line";
 import { Vector } from "./Vector";
 import { Vertex } from "./Vertex";
 import { UIDGenerator } from "./UIDGenerator";
-import { SVGSerializable, UID, XYCoords } from "./interfaces";
+import { IBounded, Intersectable, SVGSerializable, UID, XYCoords } from "./interfaces";
 import { CubicBezierCurve } from "./CubicBezierCurve";
+import { VertTuple } from "./VertTuple";
+import { Circle } from "./Circle";
+import { Bounds } from "./Bounds";
 
 /**
  * @classdesc An ellipse class based on two vertices [centerX,centerY] and [radiusX,radiusY].
@@ -36,7 +43,7 @@ import { CubicBezierCurve } from "./CubicBezierCurve";
  * @requires UIDGenerator
  * @requires Vertex
  */
-export class VEllipse implements SVGSerializable {
+export class VEllipse implements IBounded, Intersectable, SVGSerializable {
   /**
    * Required to generate proper CSS classes and other class related IDs.
    **/
@@ -154,12 +161,119 @@ export class VEllipse implements SVGSerializable {
    * @return {number} The signed vertical radius of this ellipse.
    */
   signedRadiusV(): number {
-    // return Math.abs(this.axis.y - this.center.y);
     // Rotate axis back to origin before calculating radius
-    // return Math.abs(new Vertex(this.axis).rotate(-this.rotation,this.center).y - this.center.y);
     return new Vertex(this.axis).rotate(-this.rotation, this.center).y - this.center.y;
   }
 
+  /**
+   * Get the the minima and maxima (points) of this (rotated) ellipse.
+   *
+   * @method getExtremePoints
+   * @instance
+   * @memberof VEllipse
+   * @return {[Vertex, Vertex, Vertex, Vertex]} Get the the minima and maxima (points) of this (rotated) ellipse.
+   */
+  getExtremePoints(): [Vertex, Vertex, Vertex, Vertex] {
+    const a: number = this.radiusH();
+    const b: number = this.radiusV();
+
+    // Calculate t_x values
+    const t_x1: number = Math.atan2(-b * Math.sin(this.rotation), a * Math.cos(this.rotation));
+    const t_x2: number = t_x1 + Math.PI;
+
+    // Calculate x values at t_x
+    const x_x1: number =
+      this.center.x + a * Math.cos(t_x1) * Math.cos(this.rotation) - b * Math.sin(t_x1) * Math.sin(this.rotation);
+    const y_x1: number =
+      this.center.y + a * Math.cos(t_x1) * Math.sin(this.rotation) + b * Math.sin(t_x1) * Math.cos(this.rotation);
+    const x_x2: number =
+      this.center.x + a * Math.cos(t_x2) * Math.cos(this.rotation) - b * Math.sin(t_x2) * Math.sin(this.rotation);
+    const y_x2: number =
+      this.center.y + a * Math.cos(t_x2) * Math.sin(this.rotation) + b * Math.sin(t_x2) * Math.cos(this.rotation);
+
+    let x_max: Vertex, x_min: Vertex;
+    if (x_x1 > x_x2) {
+      x_max = new Vertex(x_x1, y_x1);
+      x_min = new Vertex(x_x2, y_x2);
+    } else {
+      x_max = new Vertex(x_x2, y_x2);
+      x_min = new Vertex(x_x1, y_x1);
+    }
+
+    // Calculate t_y values
+    const t_y1: number = Math.atan2(b * Math.cos(this.rotation), a * Math.sin(this.rotation));
+    const t_y2: number = t_y1 + Math.PI;
+
+    // Calculate y values at t_y
+    const x_y1: number =
+      this.center.x + a * Math.cos(t_y1) * Math.cos(this.rotation) - b * Math.sin(t_y1) * Math.sin(this.rotation);
+    const y_y1: number =
+      this.center.y + a * Math.cos(t_y1) * Math.sin(this.rotation) + b * Math.sin(t_y1) * Math.cos(this.rotation);
+    const x_y2: number =
+      this.center.x + a * Math.cos(t_y2) * Math.cos(this.rotation) - b * Math.sin(t_y2) * Math.sin(this.rotation);
+    const y_y2: number =
+      this.center.y + a * Math.cos(t_y2) * Math.sin(this.rotation) + b * Math.sin(t_y2) * Math.cos(this.rotation);
+
+    let y_max: Vertex, y_min: Vertex;
+    if (y_y1 > y_y2) {
+      y_max = new Vertex(x_y1, y_y1);
+      y_min = new Vertex(x_y2, y_y2);
+    } else {
+      y_max = new Vertex(x_y2, y_y2);
+      y_min = new Vertex(x_y1, y_y1);
+    }
+
+    return [x_max, x_min, y_max, y_min];
+  }
+
+  //--- BEGIN --- Implement interface `IBounded`
+  /**
+   * Get the bounds of this ellipse.
+   *
+   * The bounds are approximated by the underlying segment buffer; the more segment there are,
+   * the more accurate will be the returned bounds.
+   *
+   * @method getBounds
+   * @instance
+   * @memberof VEllipse
+   * @return {Bounds} The bounds of this ellipse.
+   **/
+  getBounds(): Bounds {
+    // Thanks to Cuixiping
+    //    https://stackoverflow.com/questions/87734/how-do-you-calculate-the-axis-aligned-bounding-box-of-an-ellipse
+    const r1: number = this.radiusH();
+    const r2: number = this.radiusV();
+
+    const ux: number = r1 * Math.cos(this.rotation);
+    const uy: number = r1 * Math.sin(this.rotation);
+    const vx: number = r2 * Math.cos(this.rotation + Math.PI / 2);
+    const vy: number = r2 * Math.sin(this.rotation + Math.PI / 2);
+
+    const bbox_halfwidth = Math.sqrt(ux * ux + vx * vx);
+    const bbox_halfheight = Math.sqrt(uy * uy + vy * vy);
+
+    return new Bounds(
+      { x: this.center.x - bbox_halfwidth, y: this.center.y - bbox_halfheight },
+      { x: this.center.x + bbox_halfwidth, y: this.center.y + bbox_halfheight }
+    );
+  }
+  //--- BEGIN --- Implement interface `IBounded`
+
+  /**
+   * Move the ellipse by the given amount. This is equivalent by moving the `center` and `axis` points.
+   *
+   * @method move
+   * @param {XYCoords} amount - The amount to move.
+   * @instance
+   * @memberof VEllipse
+   * @return {VEllipse} this for chaining
+   **/
+  move(amount: XYCoords): VEllipse {
+    this.center.add(amount);
+    this.axis.add(amount);
+    return this;
+  }
+
   /**
    * Scale this ellipse by the given factor from the center point. The factor will be applied to both radii.
    *
@@ -222,9 +336,8 @@ export class VEllipse implements SVGSerializable {
    * @param {number} angle - The angle to get the normal vector at.
    * @param {number=1.0} length - [optional, default=1] The length of the returned vector.
    */
-
   normalAt(angle: number, length?: number): Vector {
-    const point: Vertex = this.vertAt(angle);
+    const point: Vertex = this.vertAt(angle - this.rotation); // HERE IS THE CORRECT BEHAVIOR!
     const foci: [Vertex, Vertex] = this.getFoci();
     // Calculate the angle between [point,focusA] and [point,focusB]
     const angleA: number = new Line(point, foci[0]).angle();
@@ -236,11 +349,14 @@ export class VEllipse implements SVGSerializable {
       .addX(50)
       .clone()
       .rotate(Math.PI + centerAngle, point);
-    if (this.center.distance(endPointA) < this.center.distance(endPointB)) {
-      return new Vector(point, endPointB);
-    } else {
-      return new Vector(point, endPointA);
+    const resultVector: Vector =
+      this.center.distance(endPointA) < this.center.distance(endPointB)
+        ? new Vector(point, endPointB)
+        : new Vector(point, endPointA);
+    if (typeof length === "number") {
+      resultVector.setLength(length);
     }
+    return resultVector;
   }
 
   /**
@@ -260,9 +376,7 @@ export class VEllipse implements SVGSerializable {
    */
   tangentAt(angle: number, length?: number): Vector {
     const normal: Vector = this.normalAt(angle, length);
-    // Rotate the normal by 90 degrees, then it is the tangent.
-    normal.b.rotate(Math.PI / 2, normal.a);
-    return normal;
+    return normal.inv().perp();
   }
 
   /**
@@ -315,6 +429,8 @@ export class VEllipse implements SVGSerializable {
   /**
    * Get equally distributed points on the outline of this ellipse.
    *
+   * @method getEquidistantVertices
+   * @instance
    * @param {number} pointCount - The number of points.
    * @returns {Array<Vertex>}
    */
@@ -327,6 +443,85 @@ export class VEllipse implements SVGSerializable {
     return result;
   }
 
+  //--- BEGIN --- Implement interface `Intersectable`
+  /**
+   * Get the line intersections as vectors with this ellipse.
+   *
+   * @method lineIntersections
+   * @instance
+   * @param {VertTuple<Vector> ray - The line/ray to intersect this ellipse with.
+   * @param {boolean} inVectorBoundsOnly - (default=false) Set to true if only intersections within the vector bounds are of interest.
+   * @returns
+   */
+  lineIntersections(ray: VertTuple<Vector>, inVectorBoundsOnly: boolean = false): Array<Vertex> {
+    // Question: what happens to extreme versions when ellipse is a line (width or height is zero)?
+    //           This would result in a Division_by_Zero exception!
+
+    // Step A: create clones for operations (keep originals unchanged)
+    const ellipseCopy: VEllipse = this.clone(); // VEllipse
+    const rayCopy: VertTuple<Vector> = ray.clone(); // Vector
+
+    // Step B: move both so ellipse's center is located at (0,0)
+    const moveAmount: Vertex = ellipseCopy.center.clone().inv();
+    ellipseCopy.move(moveAmount);
+    rayCopy.add(moveAmount);
+
+    // Step C: rotate eclipse backwards it's rotation, so that rotation is zero (0.0).
+    //         Rotate together with ray!
+    const rotationAmount: number = -ellipseCopy.rotation;
+    ellipseCopy.rotate(rotationAmount); // Rotation around (0,0) = center of translated ellipse
+    rayCopy.a.rotate(rotationAmount, ellipseCopy.center);
+    rayCopy.b.rotate(rotationAmount, ellipseCopy.center);
+
+    // Step D: find x/y factors to use for scaling to transform the ellipse to a circle.
+    //         Scale together with vector ray.
+    const radiusH: number = ellipseCopy.radiusH();
+    const radiusV: number = ellipseCopy.radiusV();
+    const scalingFactors: XYCoords = radiusH > radiusV ? { x: radiusV / radiusH, y: 1.0 } : { x: 1.0, y: radiusH / radiusV };
+
+    // Step E: scale ellipse AND ray by calculated factors.
+    ellipseCopy.axis.scaleXY(scalingFactors);
+    rayCopy.a.scaleXY(scalingFactors);
+    rayCopy.b.scaleXY(scalingFactors);
+
+    // Intermediate result: now the ellipse is transformed to a circle and we can calculate intersections :)
+    // Step F: calculate circle+line intersecions
+    const tmpCircle: Circle = new Circle(new Vertex(), ellipseCopy.radiusH()); // radiusH() === radiusV()
+    const intersections: Vertex[] = tmpCircle.lineIntersections(rayCopy, inVectorBoundsOnly);
+
+    // Step G: transform intersecions back to original configuration
+    intersections.forEach(function (intersectionPoint) {
+      // Reverse transformation from above.
+      intersectionPoint.scaleXY({ x: 1 / scalingFactors.x, y: 1 / scalingFactors.y }, ellipseCopy.center);
+      intersectionPoint.rotate(-rotationAmount, ellipseCopy.center);
+      intersectionPoint.sub(moveAmount);
+    });
+
+    return intersections;
+  }
+
+  /**
+   * Get all line intersections of this polygon and their tangents along the shape.
+   *
+   * This method returns all intersection tangents (as vectors) with this shape. The returned array of vectors is in no specific order.
+   *
+   * @param line
+   * @param lineIntersectionTangents
+   * @returns
+   */
+  lineIntersectionTangents(line: VertTuple<any>, inVectorBoundsOnly: boolean = false): Array<Vector> {
+    // Find the intersections of all lines plus their tangents inside the circle bounds
+    const interSectionPoints: Array<Vertex> = this.lineIntersections(line, inVectorBoundsOnly);
+    return interSectionPoints.map((vert: Vertex) => {
+      // Calculate angle
+      const lineFromCenter = new Line(this.center, vert);
+      const angle: number = lineFromCenter.angle();
+      // Calculate tangent at angle
+      return this.tangentAt(angle);
+    });
+  }
+  //--- END --- Implement interface `Intersectable`
+
   /**
    * Convert this ellipse into cubic Bézier curves.
    *
@@ -340,7 +535,7 @@ export class VEllipse implements SVGSerializable {
     //    http://www.spaceroots.org/documents/ellipse/node22.html
 
     // Note that ellipses with radiusH=0 or radiusV=0 cannot be represented as Bézier curves.
-    // Return a single line here (as a Bézier curve)
+    // Return a single line here (as a Bézier curve)?
     // if (Math.abs(this.radiusV()) < 0.00001) {
     //   const radiusH = this.radiusH();
     //   return [
@@ -372,10 +567,10 @@ export class VEllipse implements SVGSerializable {
 
     const curves: Array<CubicBezierCurve> = [];
     const angles: Array<number> = VEllipse.utils.equidistantVertAngles(radiusH, radiusV, segmentCount);
-    let curAngle: number = angles[0];
+    let curAngle: number = angles[0] + this.rotation;
     let startPoint: Vertex = this.vertAt(curAngle);
     for (var i = 0; i < angles.length; i++) {
-      let nextAngle = angles[(i + 1) % angles.length];
+      let nextAngle = angles[(i + 1) % angles.length] + this.rotation;
       let endPoint: Vertex = this.vertAt(nextAngle);
 
       if (Math.abs(radiusV) < 0.0001 || Math.abs(radiusH) < 0.0001) {
@@ -389,8 +584,8 @@ export class VEllipse implements SVGSerializable {
         );
         curves.push(curve);
       } else {
-        let startTangent: Vector = this.tangentAt(curAngle);
-        let endTangent: Vector = this.tangentAt(nextAngle);
+        let startTangent: Vector = this.tangentAt(curAngle + this.rotation);
+        let endTangent: Vector = this.tangentAt(nextAngle + this.rotation);
 
         // Find intersection (ignore that the result might be null in some extreme cases)
         let intersection: Vertex = startTangent.intersection(endTangent) as Vertex;

package/src/ts/VEllipseSector.ts

@@ -6,9 +6,17 @@
  * @date     2021-02-26
  * @modified 2022-02-02 Added the `destroy` method.
  * @modified 2022-11-01 Tweaked the `endpointToCenterParameters` function to handle negative values, too, without errors.
- * @version  1.1.1
+ * @modified 2025-04-01 Adapting a the `toCubicBezier` calculation to match an underlying change in the vertAt and tangentAt calculation of ellipses (was required to hamonize both methods with circles).
+ * @modified 2025-04-02 Adding `VEllipseSector.containsAngle` method.
+ * @modified 2025-04-02 Adding `VEllipseSector.lineIntersections` and `VEllipseSector.lineIntersectionTangents` and implementing `Intersectable`.
+ * @modified 2025-04-07 Adding value wrapping (0 to TWO_PI) to the `VEllipseSector.containsAngle` method.
+ * @modified 2025-04-09 Adding the `VEllipseSector.move` method.
+ * @modified 2025-04-19 Added the `VEllipseSector.getStartPoint` and `getEndPoint` methods.
+ * @modified 2025-04-23 Added the `VEllipseSector.getBounds` method.
+ * @version  1.2.0
  */
 
+import { Bounds } from "./Bounds";
 import { CubicBezierCurve } from "./CubicBezierCurve";
 import { geomutils } from "./geomutils";
 import { SVGPathParams, UID, XYCoords } from "./interfaces";
@@ -17,6 +25,7 @@ import { UIDGenerator } from "./UIDGenerator";
 import { Vector } from "./Vector";
 import { VEllipse } from "./VEllipse";
 import { Vertex } from "./Vertex";
+import { VertTuple } from "./VertTuple";
 
 /**
  * @classdesc A class for elliptic sectors.
@@ -93,6 +102,143 @@ export class VEllipseSector {
     this.endAngle = geomutils.wrapMinMax(endAngle, 0, Math.PI * 2);
   }
 
+  /**
+   * Move the ellipse sector by the given amount.
+   *
+   * @method move
+   * @param {XYCoords} amount - The amount to move.
+   * @instance
+   * @memberof VEllipseSector
+   * @return {VEllipseSector} this for chaining
+   **/
+  move(amount: XYCoords): VEllipseSector {
+    this.ellipse.move(amount);
+    return this;
+  }
+
+  /**
+   * Checks wether the given angle (must be inside 0 and PI*2) is contained inside this sector.
+   *
+   * @param {number} angle - The numeric angle to check.
+   * @method containsAngle
+   * @instance
+   * @memberof VEllipseSectpr
+   * @return {boolean} True if (and only if) this sector contains the given angle.
+   */
+  containsAngle(angle: number) {
+    angle = geomutils.mapAngleTo2PI(angle); // wrapMinMax(angle, 0, Math.PI * 2);
+    const sAngle: number = geomutils.mapAngleTo2PI(this.startAngle);
+    const eAngle: number = geomutils.mapAngleTo2PI(this.endAngle);
+    // TODO: cleanup
+    // if (this.startAngle <= this.endAngle) {
+    //   return angle >= this.startAngle && angle < this.endAngle;
+    // } else {
+    //   // startAngle > endAngle
+    //   return angle >= this.startAngle || angle < this.endAngle;
+    // }
+    if (sAngle <= eAngle) {
+      return angle >= sAngle && angle < eAngle;
+    } else {
+      // startAngle > endAngle
+      return angle >= sAngle || angle < eAngle;
+    }
+  }
+
+  /**
+   * Get the sectors starting point (on the underlying ellipse, located at the start angle).
+   *
+   * @method getStartPoint
+   * @instance
+   * @memberof VEllipseSector
+   * @return {Vertex} The sector's stating point.
+   */
+  getStartPoint(): Vertex {
+    return this.ellipse.vertAt(this.startAngle);
+  }
+
+  /**
+   * Get the sectors ending point (on the underlying ellipse, located at the end angle).
+   *
+   * @method getEndPoint
+   * @instance
+   * @memberof VEllipseSector
+   * @return {Vertex} The sector's ending point.
+   */
+  getEndPoint(): Vertex {
+    return this.ellipse.vertAt(this.endAngle);
+  }
+
+  //--- BEGIN --- Implement interface `IBounded`
+  /**
+   * Get the bounds of this elliptic sector.
+   *
+   * The bounds are approximated by the underlying segment buffer; the more segment there are,
+   * the more accurate will be the returned bounds.
+   *
+   * @method getBounds
+   * @instance
+   * @memberof VEllipse
+   * @return {Bounds} The bounds of this elliptic sector.
+   **/
+  getBounds(): Bounds {
+    // Calculage angles from east, west, north and south box points and check if they are inside
+    const extremes = this.ellipse.getExtremePoints();
+    const candidates: Array<Vertex> = extremes.filter(point => {
+      const angle: number = new Line(this.ellipse.center, point).angle() - this.ellipse.rotation;
+      return this.containsAngle(angle);
+    });
+    return Bounds.computeFromVertices([this.getStartPoint(), this.getEndPoint()].concat(candidates));
+  }
+
+  //--- BEGIN --- Implement interface `Intersectable`
+  /**
+   * Get the line intersections as vectors with this ellipse.
+   *
+   * @method lineIntersections
+   * @instance
+   * @memberof VEllipseSectpr
+   * @param {VertTuple<Vector>} ray - The line/ray to intersect this ellipse with.
+   * @param {boolean} inVectorBoundsOnly - (default=false) Set to true if only intersections within the vector bounds are of interest.
+   * @returns
+   */
+  lineIntersections(ray: VertTuple<Vector>, inVectorBoundsOnly: boolean = false): Array<Vertex> {
+    // First get all line intersections from underlying ellipse.
+    const ellipseIntersections: Array<Vertex> = this.ellipse.lineIntersections(ray, inVectorBoundsOnly);
+    // Drop all intersection points that are not contained in the circle sectors bounds.
+    const tmpLine = new Line(this.ellipse.center, new Vertex());
+    return ellipseIntersections.filter((intersectionPoint: Vertex) => {
+      tmpLine.b.set(intersectionPoint);
+      const lineAngle = tmpLine.angle();
+      return this.containsAngle(lineAngle - this.ellipse.rotation);
+    });
+  }
+
+  /**
+   * Get all line intersections of this polygon and their tangents along the shape.
+   *
+   * This method returns all intersection tangents (as vectors) with this shape. The returned array of vectors is in no specific order.
+   *
+   * @method lineIntersections
+   * @memberof VEllipseSectpr
+   * @param line
+   * @param lineIntersectionTangents
+   * @returns
+   */
+  lineIntersectionTangents(line: VertTuple<any>, inVectorBoundsOnly: boolean = false): Array<Vector> {
+    // Find the intersections of all lines plus their tangents inside the circle bounds
+    const interSectionPoints: Array<Vertex> = this.lineIntersections(line, inVectorBoundsOnly);
+    return interSectionPoints.map((vert: Vertex) => {
+      // Calculate angle
+      const lineFromCenter = new Line(this.ellipse.center, vert);
+      const angle: number = lineFromCenter.angle();
+      // console.log("angle", (angle / Math.PI) * 180.0);
+      // const angle = Math.random() * Math.PI * 2; // TODO
+      // Calculate tangent at angle
+      return this.ellipse.tangentAt(angle);
+    });
+  }
+  //--- END --- Implement interface `Intersectable`
+
   /**
    * Convert this elliptic sector into cubic Bézier curves.
    *
@@ -125,8 +271,8 @@ export class VEllipseSector {
       let nextAngle = angles[(i + 1) % angles.length];
       let endPoint: Vertex = this.ellipse.vertAt(nextAngle);
 
-      let startTangent: Vector = this.ellipse.tangentAt(curAngle);
-      let endTangent: Vector = this.ellipse.tangentAt(nextAngle);
+      let startTangent: Vector = this.ellipse.tangentAt(curAngle + this.ellipse.rotation);
+      let endTangent: Vector = this.ellipse.tangentAt(nextAngle + this.ellipse.rotation);
 
       // Distorted ellipses can only be approximated by linear Bézier segments
       if (Math.abs(radiusV) < 0.0001 || Math.abs(radiusH) < 0.0001) {
@@ -257,23 +403,23 @@ export class VEllipseSector {
       endAngle: number,
       fullEllipsePointCount: number
     ): Array<number> => {
-      var ellipseAngles = VEllipse.utils.equidistantVertAngles(radiusH, radiusV, fullEllipsePointCount);
+      var ellipseAngles: number[] = VEllipse.utils.equidistantVertAngles(radiusH, radiusV, fullEllipsePointCount);
       ellipseAngles = ellipseAngles.map((angle: number) => VEllipseSector.ellipseSectorUtils.normalizeAngle(angle));
 
-      var angleIsInRange = (angle: number) => {
+      const angleIsInRange = (angle: number) => {
         if (startAngle < endAngle) return angle >= startAngle && angle <= endAngle;
         else return angle >= startAngle || (angle <= endAngle && angle >= 0);
       };
       // Drop all angles outside the sector
-      var ellipseAngles = ellipseAngles.filter(angleIsInRange);
+      ellipseAngles = ellipseAngles.filter(angleIsInRange);
 
       // Now we need to sort the angles to the first one in the array is the closest to startAngle.
       // --> find the angle that is closest to the start angle
-      var startIndex = VEllipseSector.ellipseSectorUtils.findClosestToStartAngle(startAngle, endAngle, ellipseAngles);
+      const startIndex: number = VEllipseSector.ellipseSectorUtils.findClosestToStartAngle(startAngle, endAngle, ellipseAngles);
 
       // Bring all angles into the correct order
       //    Idea: use splice or slice here?
-      var angles: Array<number> = [];
+      const angles: Array<number> = [];
       for (var i = 0; i < ellipseAngles.length; i++) {
         angles.push(ellipseAngles[(startIndex + i) % ellipseAngles.length]);
       }

package/src/ts/Vector.ts

@@ -12,7 +12,8 @@
  * @modified 2022-02-02 Added the `destroy` method.
  * @modified 2022-02-02 Cleared the `Vector.toSVGString` function (deprecated). Use `drawutilssvg` instead.
  * @modified 2022-10-25 Added the `getOrthogonal` method.
- * @version  1.5.0
+ * @modified 2025-04-14 Added the `Vector.rotate(number)` method.
+ * @version  1.6.0
  *
  * @file Vector
  * @public
@@ -53,7 +54,6 @@ export class Vector extends VertTuple<Vector> implements SVGSerializable {
   /**
    * Get the perpendicular of this vector which is located at a.
    *
-   * @param {Number} t The position on the vector.
    * @return {Vector} A new vector being the perpendicular of this vector sitting on a.
    **/
   perp(): Vector {
@@ -136,6 +136,20 @@ export class Vector extends VertTuple<Vector> implements SVGSerializable {
     return new Vector(linePoint, startPoint.add(this.a));
   }
 
+  /**
+   * Rotate this vector by the given angle around the first point `a`.
+   *
+   * @name rotate
+   * @method rotate
+   * @return {Vector} this - for chaining.
+   * @instance
+   * @memberof Vector
+   */
+  rotate(angle: number): Vector {
+    this.b.rotate(angle, this.a);
+    return this;
+  }
+
   static utils = {
     /**
      * Generate a four-point arrow head, starting at the vector end minus the

package/src/ts/VertTuple.ts

@@ -13,7 +13,10 @@
  * @modified 2024-09-10 Chaging the first param of `pointDistance` from `Vertex` to less strict type `XYCoords`. This should not break anything.
  * @modified 2024-09-10 Adding the optional `epsilon` param to the `hasPoint` method.
  * @modified 2024-12-02 Added the `epsilon` param to the `colinear` method. Default is 1.0e-6.
- * @version 1.3.0
+ * @modified 2025-03-31 Added the `VertTuple.revert` method.
+ * @modified 2025-04-15 Changed param of `VertTuple.moveTo` method from `Vertex` to `XYCoords`.
+ * @modified 2025-04-15 Added method `VertTuple.move` method.
+ * @version 1.4.0
  */
 
 import { Vertex } from "./Vertex";
@@ -124,9 +127,9 @@ export class VertTuple<T extends VertTuple<T>> {
    *
    * @method add
    * @param {XYCoords} amount The amount (x,y) to add.
-   * @return {Line} this
    * @instance
    * @memberof VertTuple
+   * @return {VertTuple<T>} this
    **/
   add(amount: XYCoords): VertTuple<T> {
     this.a.add(amount);
@@ -134,6 +137,23 @@ export class VertTuple<T extends VertTuple<T>> {
     return this;
   }
 
+  /**
+   * Reverse this vertex tuple: a becomes b, and b becomes a.
+   * This operation is in-place.
+   *
+   * @method add
+   * @param {XYCoords} amount The amount (x,y) to add.
+   * @instance
+   * @memberof VertTuple
+   * @return {VertTuple<T>} this
+   */
+  revert(): VertTuple<T> {
+    const tmp: Vertex = this.a;
+    this.a = this.b;
+    this.b = tmp;
+    return this;
+  }
+
   /**
    * Normalize this line (set to length 1).
    *
@@ -165,18 +185,33 @@ export class VertTuple<T extends VertTuple<T>> {
    * Move this line to a new location.
    *
    * @method moveTo
-   * @param {Vertex} newA - The new desired location of 'a'. Vertex 'b' will be moved, too.
+   * @param {XYCoords} newA - The new desired location of 'a'. Vertex 'b' will be moved, too.
    * @return {VertTuple} this
    * @instance
    * @memberof VertTuple
    **/
-  moveTo(newA: Vertex): VertTuple<T> {
+  moveTo(newA: XYCoords): VertTuple<T> {
     let diff = this.a.difference(newA);
     this.a.add(diff);
     this.b.add(diff);
     return this;
   }
 
+  /**
+   * Move this line by the given amount
+   *
+   * @method move
+   * @param {XYCoords} amount - The amount to move both point of this tuple.
+   * @return {VertTuple} this
+   * @instance
+   * @memberof VertTuple
+   **/
+  move(amount: XYCoords): VertTuple<T> {
+    this.a.add(amount);
+    this.b.add(amount);
+    return this;
+  }
+
   /**
    * Get the angle between this and the passed line (in radians).
    *