@bitblit/ratchet-common 6.0.146-alpha → 6.0.148-alpha

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@bitblit/ratchet-common",
-  "version": "6.0.146-alpha",
+  "version": "6.0.148-alpha",
   "description": "Common tools for general use",
   "type": "module",
   "files": [
+    "src/**",
     "lib/**",
     "bin/**"
   ],

package/src/2d/line-2d.ts

@@ -0,0 +1,6 @@
+import { Point2d } from './point-2d.js';
+
+export interface Line2d {
+  p1: Point2d;
+  p2: Point2d;
+}

package/src/2d/matrix-factory.ts

@@ -0,0 +1,94 @@
+import { TransformationMatrix } from "./transformation-matrix.js";
+
+export class MatrixFactory {
+  // Prevent instantiation
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {}
+
+  public static multiply(tx: TransformationMatrix[]): TransformationMatrix {
+    let rval: TransformationMatrix = MatrixFactory.identity();
+    tx.forEach(t=>{
+      rval = {
+        a: (rval.a * t.a) + (rval.b * t.c) + ((rval.u ?? 0) * 0),
+        b: (rval.a * t.b) + (rval.b * t.d) + ((rval.u ?? 0) * 0),
+        u: (rval.a * (t.u ?? 0)) + (rval.b * (t.v ?? 0)) + ((rval.u ?? 0) * 1),
+        c: (rval.c * t.a) + (rval.d * t.c) + ((rval.v ?? 0) * 0),
+        d: (rval.c * t.b) + (rval.d * t.d) + ((rval.v ?? 0)  * 0),
+        v: (rval.c * (t.u ?? 0)) + (rval.d * (t.v ?? 0)) + ((rval.v ?? 0)  * 1),
+      };
+    });
+    return rval;
+  }
+
+  public static translate(xMove: number, yMove: number): TransformationMatrix {
+    const rval: TransformationMatrix = MatrixFactory.identity();
+    rval.u = xMove;
+    rval.v = yMove;
+    return rval;
+  }
+
+
+  public static scaleUniform(scale: number): TransformationMatrix {
+    return MatrixFactory.scale(scale, scale);
+  }
+
+  public static scale(xScale: number, yScale: number): TransformationMatrix {
+    return {
+      a: xScale,
+      b: 0,
+      c: 0,
+      d: yScale,
+    }
+  }
+
+  public static rotate(angleTheta: number): TransformationMatrix {
+    return {
+      a: Math.cos(angleTheta),
+      b: -1 * Math.sin(angleTheta),
+      c: Math.sin(angleTheta),
+      d: Math.cos(angleTheta)
+    };
+  }
+
+  public static shear(xShear: number, yShear: number): TransformationMatrix {
+    return {
+      a: 1,
+      b: xShear,
+      c: yShear,
+      d: 1
+    }
+  }
+
+  public static mirrorAboutYAxis(): TransformationMatrix {
+    return {
+      a: -1,
+      b: 0,
+      c: 0,
+      d: 1
+    }
+  }
+
+  public static mirrorAboutXAxis(): TransformationMatrix {
+    return {
+      a: 1,
+      b: 0,
+      c: 0,
+      d: -1
+    }
+  }
+
+
+  public static identity(): TransformationMatrix {
+    return {
+      a: 1,
+      b: 0,
+      c: 0,
+      d: 1,
+      u: 0,
+      v: 0
+    }
+  }
+
+
+
+}

package/src/2d/plane-2d-type.ts

@@ -0,0 +1,6 @@
+export enum Plane2dType {
+  BottomLeft = 'BottomLeft', // x increases to the right, y increases going up (common cartesian)
+  BottomRight = 'BottomRight', // x increases to the left, y increases going up (uncommon)
+  TopLeft = 'TopLeft', // x increases to the right, y increases going down (common graphics)
+  TopRight = 'TopRight' // x increases to the left, y increases going down (uncommon)
+}

package/src/2d/plane-2d.ts

@@ -0,0 +1,7 @@
+import { Plane2dType } from "./plane-2d-type.js";
+
+export interface Plane2d {
+  height: number;
+  width: number;
+  type: Plane2dType;
+}

package/src/2d/point-2d.ts

@@ -0,0 +1,4 @@
+export interface Point2d {
+  x: number;
+  y: number;
+}

package/src/2d/poly-line-2d.ts

@@ -0,0 +1,5 @@
+import { Point2d } from './point-2d.js';
+
+export interface PolyLine2d {
+  pts: Point2d[];
+}

package/src/2d/ratchet-2d.spec.ts

@@ -0,0 +1,205 @@
+import { Ratchet2d } from "./ratchet-2d.js";
+import { Point2d } from "./point-2d.js";
+import { Plane2d } from "./plane-2d.js";
+import { describe, expect, test } from "vitest";
+import { TransformationMatrix } from "./transformation-matrix.js";
+import { MatrixFactory } from "./matrix-factory.js";
+import { Plane2dType } from "./plane-2d-type.js";
+
+describe('#ratchet2d', function () {
+  test('should scale', () => {
+    const pts: Point2d[] = [{x:0,y:0},{x:1, y:1}];
+    const ptEven: Point2d[] = Ratchet2d.applyTransform(pts, MatrixFactory.scaleUniform(2));
+    expect(ptEven.length).toEqual(2);
+    expect(ptEven[0].x).toEqual(0);
+    expect(ptEven[1].x).toEqual(2);
+    expect(ptEven[1].y).toEqual(2);
+
+    const ptX: Point2d[] = Ratchet2d.applyTransform(pts, MatrixFactory.scale(2,1));
+    expect(ptX.length).toEqual(2);
+    expect(ptX[0].x).toEqual(0);
+    expect(ptX[1].x).toEqual(2);
+    expect(ptX[1].y).toEqual(1);
+  });
+
+  test('should mirror', () => {
+    const pts: Point2d[] = [{x:0,y:0},{x:1, y:1}];
+    const ptY: Point2d[] = Ratchet2d.applyTransform(pts, MatrixFactory.mirrorAboutYAxis());
+    expect(ptY.length).toEqual(2);
+    expect(ptY[0].x).toEqual(0);
+    expect(ptY[1].x).toEqual(-1);
+    expect(ptY[1].y).toEqual(1);
+
+    const ptX: Point2d[] = Ratchet2d.applyTransform(pts, MatrixFactory.mirrorAboutXAxis());
+    expect(ptX.length).toEqual(2);
+    expect(ptX[0].x).toEqual(0);
+    expect(ptX[1].x).toEqual(1);
+    expect(ptX[1].y).toEqual(-1);
+  });
+
+  test('should combine', () => {
+    const pts: Point2d[] = [{x:0,y:0},{x:1, y:1}];
+    const tx: TransformationMatrix = MatrixFactory.multiply([MatrixFactory.scaleUniform(2), MatrixFactory.mirrorAboutYAxis()]);
+    const ptC: Point2d[] = Ratchet2d.applyTransform(pts, tx);
+    expect(ptC.length).toEqual(2);
+    expect(ptC[0].x).toEqual(0);
+    expect(ptC[1].x).toEqual(-2);
+    expect(ptC[1].y).toEqual(2);
+  });
+
+  test('should check for valid planes', () => {
+    expect(Ratchet2d.validPlane(null)).toEqual(false);
+    expect(Ratchet2d.validPlane({ width: null, height: null, type: Plane2dType.BottomLeft })).toEqual(false);
+    expect(Ratchet2d.validPlane({ width: 0, height: null, type: Plane2dType.BottomLeft })).toEqual(false);
+    expect(Ratchet2d.validPlane({ width: 0, height: 2, type: Plane2dType.BottomLeft })).toEqual(false);
+    expect(Ratchet2d.validPlane({ width: 1, height: 7, type: Plane2dType.BottomLeft })).toEqual(true);
+  });
+
+  test('should check for valid lines', () => {
+    expect(Ratchet2d.validLine(null)).toEqual(false);
+    expect(Ratchet2d.validLine({ p1: null, p2: null })).toEqual(false);
+    expect(Ratchet2d.validLine({ p1: { x: null, y: 0 }, p2: null })).toEqual(false);
+    expect(Ratchet2d.validLine({ p1: { x: 0, y: 0 }, p2: { x: 27, y: null } })).toEqual(false);
+    expect(Ratchet2d.validLine({ p1: { x: 0, y: 0 }, p2: { x: 27, y: 0 } })).toEqual(true);
+    expect(Ratchet2d.validLine({ p1: { x: 1, y: 0 }, p2: { x: 1, y: 0 } })).toEqual(false); // same point
+    expect(Ratchet2d.validLine({ p1: { x: 0, y: 0 }, p2: { x: 27, y: 13 } })).toEqual(true);
+  });
+
+  test('should transform points from one plane to another (scale)', () => {
+    const plane1: Plane2d = { height: 10, width: 10, type: Plane2dType.BottomLeft };
+    const plane2: Plane2d = { height: 100, width: 50, type: Plane2dType.BottomLeft };
+
+    const p1: Point2d = { x: 5, y: 5 };
+    const out1: Point2d = Ratchet2d.transformPointToNewPlane(p1, plane1, plane2);
+    const out2: Point2d = Ratchet2d.transformPointToNewPlane(out1, plane2, plane1);
+
+    expect(out1.x).toEqual(25);
+    expect(out1.y).toEqual(50);
+
+    expect(out2.x).toEqual(p1.x);
+    expect(out2.y).toEqual(p1.y);
+  });
+
+  test('should transform points from one plane to another (mirror)', () => {
+    const plane1: Plane2d = { height: 10, width: 10, type: Plane2dType.BottomLeft };
+    const plane2: Plane2d = { height: 10, width: 10, type: Plane2dType.TopRight };
+
+    const p1: Point2d = { x: 2, y: 8 };
+    const out1: Point2d = Ratchet2d.transformPointToNewPlane(p1, plane1, plane2);
+    const out2: Point2d = Ratchet2d.transformPointToNewPlane(out1, plane2, plane1);
+
+    expect(out1.x).toEqual(7);
+    expect(out1.y).toEqual(1);
+
+    expect(out2.x).toEqual(p1.x);
+    expect(out2.y).toEqual(p1.y);
+  });
+
+  test('should check for containment', () => {
+    const plane: Plane2d = {
+      width: 100,
+      height: 100,
+      type: Plane2dType.BottomLeft
+    };
+
+    expect(Ratchet2d.planeContainsPoint({ x: -1, y: 10 }, plane)).toEqual(false);
+    expect(Ratchet2d.planeContainsPoint({ x: 101, y: 10 }, plane)).toEqual(false);
+    expect(Ratchet2d.planeContainsPoint({ x: 1, y: -10 }, plane)).toEqual(false);
+    expect(Ratchet2d.planeContainsPoint({ x: 10, y: 101 }, plane)).toEqual(false);
+    expect(Ratchet2d.planeContainsPoint({ x: 10, y: 100 }, plane)).toEqual(false); // Boundary condition
+    expect(Ratchet2d.planeContainsPoint({ x: 1, y: 10 }, plane)).toEqual(true);
+    expect(Ratchet2d.planeContainsPoint({ x: 10, y: 10 }, plane)).toEqual(true);
+
+    expect(
+      Ratchet2d.planeContainsPoints(
+        [
+          { x: 10, y: 10 },
+          { x: 100, y: 10 },
+        ],
+        plane,
+      ),
+    ).toEqual(false);
+    expect(
+      Ratchet2d.planeContainsPoints(
+        [
+          { x: 10, y: 10 },
+          { x: 11, y: 10 },
+        ],
+        plane,
+      ),
+    ).toEqual(true);
+
+    expect(
+      Ratchet2d.planeContainsLine(
+        {
+          p1: { x: 10, y: 10 },
+          p2: { x: 100, y: 10 },
+        },
+        plane,
+      ),
+    ).toEqual(false);
+    expect(
+      Ratchet2d.planeContainsLine(
+        {
+          p1: { x: 10, y: 10 },
+          p2: { x: 11, y: 10 },
+        },
+        plane,
+      ),
+    ).toEqual(true);
+  });
+
+  test('should fit input to curve', function () {
+    const curve: Point2d[] = [
+      { x: 0, y: 50 },
+      { x: 0.5, y: 50 },
+      { x: 0.8, y: 60 },
+      { x: 1, y: 70 },
+      { x: 1.2, y: 80 },
+      { x: 1.5, y: 90 },
+      { x: 1.6, y: 91 },
+      { x: 1.7, y: 92 },
+      { x: 1.8, y: 93 },
+      { x: 1.9, y: 94 },
+      { x: 2, y: 95 },
+      {
+        x: 3,
+        y: 98,
+      },
+      { x: 4, y: 99 },
+      { x: 5, y: 100 },
+    ];
+
+    expect(Ratchet2d.fitCurve(curve, -1)).toEqual(50);
+    expect(Ratchet2d.fitCurve(curve, 0)).toEqual(50);
+    expect(Ratchet2d.fitCurve(curve, 0.3)).toEqual(50);
+    expect(Ratchet2d.fitCurve(curve, 0.5)).toEqual(50);
+    expect(Ratchet2d.fitCurve(curve, 0.8)).toEqual(60);
+    expect(Ratchet2d.fitCurve(curve, 1)).toEqual(70);
+    expect(Ratchet2d.fitCurve(curve, 5)).toEqual(100);
+    expect(Ratchet2d.fitCurve(curve, 6)).toEqual(100);
+    expect(Ratchet2d.fitCurve(curve, 1.65)).toEqual(91.5);
+  });
+
+  test('rotate about origin', function () {
+    const points: Point2d[] = [
+      { x: 1, y: 0 },
+      { x: 2, y: 1 },
+      { x: 3, y: 2 },
+      { x: 4, y: 3 },
+      { x: 4, y: 1 },
+      { x: 6, y: 1 },
+    ];
+    //const plane: Plane2d = { height: 4, width: 8 };
+
+    const r1: Point2d[] = Ratchet2d.rotateRightAboutCartesianOrigin90Degrees(points); //, plane);
+    expect(r1.length).toEqual(6);
+
+    // Full rotation should be the same
+    const _r3: Point2d[] = Ratchet2d.rotateRightAboutCartesianOrigin90Degrees(points, 3);
+    const r2: Point2d[] = Ratchet2d.rotateRightAboutCartesianOrigin90Degrees(points, 4);
+    expect(r2.length).toEqual(6);
+    expect(r2[0].x).toEqual(points[0].x);
+    expect(r2[0].y).toEqual(points[0].y);
+  });
+});

package/src/2d/ratchet-2d.ts

@@ -0,0 +1,350 @@
+import { Point2d } from "./point-2d.js";
+import { Plane2d } from "./plane-2d.js";
+import { Line2d } from "./line-2d.js";
+import { PolyLine2d } from "./poly-line-2d.js";
+import { BooleanRatchet } from "../lang/boolean-ratchet.js";
+import { ErrorRatchet } from "../lang/error-ratchet.js";
+import { TransformationMatrix } from "./transformation-matrix.js";
+import { RequireRatchet } from "../lang/require-ratchet.js";
+import { MatrixFactory } from "./matrix-factory.js";
+import { Plane2dType } from "./plane-2d-type.js";
+
+export class Ratchet2d {
+  // Prevent instantiation
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {}
+
+  public static translateToOriginVector(points: Point2d[]): Point2d {
+    let rval: Point2d;
+    if (points?.length && Ratchet2d.validPoints(points)) {
+      rval = structuredClone(points[0]);
+      points.forEach((p) => {
+        rval.x = rval.x === null || p.x < rval.x ? p.x : rval.x;
+        rval.y = rval.y === null || p.y < rval.y ? p.y : rval.y;
+      });
+
+      rval.x *= -1;
+      rval.y *= -1;
+    } else {
+      throw ErrorRatchet.fErr('Cannot translate, points are not valid or empty : %j', points);
+    }
+    return rval;
+  }
+
+  public static minimalContainingPlane(points: Point2d[], type: Plane2dType=Plane2dType.BottomLeft): Plane2d {
+    let rval: Plane2d = null;
+    if (Ratchet2d.validPoints(points)) {
+      rval = {
+        width: 0,
+        height: 0,
+        type: type
+      };
+      points.forEach((p) => {
+        rval.width = Math.max(rval.width, p.x + 1);
+        rval.height = Math.max(rval.height, p.y + 1);
+      });
+    }
+    return rval;
+  }
+
+  public static scaleVector(src: Plane2d, dst: Plane2d): Point2d {
+    let rval: Point2d = null;
+    if (Ratchet2d.validPlane(src) && Ratchet2d.validPlane(dst)) {
+      rval = {
+        x: dst.width / src.width,
+        y: dst.height / src.height,
+      };
+    }
+    return rval;
+  }
+
+  public static samePoint(p1: Point2d, p2: Point2d): boolean {
+    return !!p1 && !!p2 && p1.x === p2.x && p1.y === p2.y;
+  }
+
+  public static atLeastOneDimensionShared(p1: Point2d, p2: Point2d): boolean {
+    return !!p1 && !!p2 && (p1.x === p2.x || p1.y === p2.y);
+  }
+
+  public static validPlane(plane: Plane2d): boolean {
+    return !!plane && !!plane.height && !!plane.width && !!plane.type; // Can use this since 0 isn't an accepted value;
+  }
+
+  public static validLine(line: Line2d): boolean {
+    return !!line && Ratchet2d.validPoint(line.p1) && Ratchet2d.validPoint(line.p2) && !Ratchet2d.samePoint(line.p1, line.p2);
+  }
+
+  public static validLines(lines: Line2d[]): boolean {
+    return !!lines && BooleanRatchet.allTrue(lines.map((l) => Ratchet2d.validLine(l)));
+  }
+
+  public static validPolyLine(pline: PolyLine2d): boolean {
+    return !!pline && pline.pts?.length > 1 && BooleanRatchet.allTrue(pline.pts.map((p) => Ratchet2d.validPoint(p)));
+  }
+
+  public static polyLineToLines(pline: PolyLine2d): Line2d[] {
+    let rval: Line2d[] = null;
+    if (Ratchet2d.validPolyLine(pline)) {
+      rval = [];
+      for (let i = 1; i < pline.pts.length; i++) {
+        rval.push({ p1: pline.pts[i - 1], p2: pline.pts[i] });
+      }
+    }
+    return rval;
+  }
+
+  public static lastPointOnPolyLine(polyLine: PolyLine2d): Point2d {
+    return Ratchet2d.validPolyLine(polyLine) ? polyLine.pts[polyLine.pts.length - 1] : null;
+  }
+
+  public static lineToPolyLine(line: Line2d): PolyLine2d {
+    return Ratchet2d.validLine(line) ? { pts: [line.p1, line.p2] } : null;
+  }
+
+  // Multiple lines are collapsed into a polyline if the end of line N is the start of line N+1
+  public static linesToPolyLines(lines: Line2d[]): PolyLine2d[] {
+    let rval: PolyLine2d[] = null;
+    if (Ratchet2d.validLines(lines)) {
+      rval = [];
+      let currentPLine: PolyLine2d = Ratchet2d.lineToPolyLine(lines[0]);
+      for (let i = 1; i < lines.length; i++) {
+        if (Ratchet2d.samePoint(Ratchet2d.lastPointOnPolyLine(currentPLine), lines[i].p1)) {
+          currentPLine.pts.push(lines[i].p2);
+        } else {
+          rval.push(currentPLine);
+          currentPLine = Ratchet2d.lineToPolyLine(lines[i]);
+        }
+      }
+      rval.push(currentPLine);
+    }
+    return rval;
+  }
+
+  public static validPoint(pt: Point2d): boolean {
+    return !!pt && pt.x != null && pt.x != undefined && pt.y !== null && pt.y !== undefined;
+  }
+
+  public static validPoints(pt: Point2d[]): boolean {
+    return (
+      !!pt &&
+      BooleanRatchet.allTrue(
+        pt.map((p) => Ratchet2d.validPoint(p)),
+        false,
+      )
+    );
+  }
+
+  public static planeContainsPoint(pt: Point2d, plane: Plane2d): boolean {
+    return Ratchet2d.validPlane(plane) && Ratchet2d.validPoint(pt) && pt.x >= 0 && pt.x < plane.width && pt.y >= 0 && pt.y < plane.height;
+  }
+
+  public static planeContainsPoints(pt: Point2d[], plane: Plane2d): boolean {
+    return pt && pt.map((p) => Ratchet2d.planeContainsPoint(p, plane)).reduce((a, i) => a && i, true);
+  }
+
+  public static linesToPoints(lines: Line2d[]): Point2d[] {
+    let rval: Point2d[] = null;
+    if (Ratchet2d.validLines(lines)) {
+      rval = lines.map((l) => [l.p1, l.p2]).flat();
+    }
+    return rval;
+  }
+
+  public static pointsToLines(points: Point2d[]): Line2d[] {
+    let rval: Line2d[] = null;
+    if (Ratchet2d.validPoints(points)) {
+      if (points.length % 2 == 0) {
+        rval = [];
+        for (let i = 0; i < points.length; i += 2) {
+          rval.push({ p1: points[i], p2: points[i + 1] });
+        }
+      } else {
+        throw new Error('Cannot convert non-even array of points into lines');
+      }
+    }
+    return rval;
+  }
+
+  public static rotateRightAboutCartesianOrigin90Degrees(points: Point2d[], times = 1): Point2d[] {
+    let rval: Point2d[] = null;
+    let translate: Point2d = { x: 0, y: 0 };
+    if (Ratchet2d.validPoints(points)) {
+      rval = Object.assign([], points);
+      translate = Ratchet2d.translateToOriginVector(rval);
+      rval = Ratchet2d.translate(rval, translate); // Move it to the origin first
+      let plane: Plane2d = Ratchet2d.minimalContainingPlane(rval);
+
+      rval = Ratchet2d.xToY(rval);
+      plane = { width: plane.height, height: plane.width, type: Plane2dType.BottomLeft };
+      translate = { x: translate.y * -1, y: translate.x * -1 };
+      rval = Ratchet2d.mirrorPointsOnPlane(rval, plane, true, false);
+      // Move it back
+      rval = Ratchet2d.translate(rval, translate);
+    }
+    const timesToRotate: number = times > 4 ? times % 4 : times; // Allow 4 since its used for testing, but not more than that
+    if (timesToRotate > 1) {
+      rval = Ratchet2d.rotateRightAboutCartesianOrigin90Degrees(rval, timesToRotate - 1);
+    }
+
+    return rval;
+  }
+
+  public static planeContainsLines(lines: Line2d[], plane: Plane2d): boolean {
+    return lines && Ratchet2d.planeContainsPoints(lines.map((l) => [l.p1, l.p2]).flat(), plane);
+  }
+
+  public static planeContainsPolyLine(pline: PolyLine2d, plane: Plane2d): boolean {
+    return Ratchet2d.planeContainsLines(Ratchet2d.polyLineToLines(pline), plane);
+  }
+
+  public static planeContainsLine(line: Line2d, plane: Plane2d): boolean {
+    return (
+      Ratchet2d.validPlane(plane) &&
+      Ratchet2d.validLine(line) &&
+      Ratchet2d.planeContainsPoint(line.p1, plane) &&
+      Ratchet2d.planeContainsPoint(line.p2, plane)
+    );
+  }
+
+  public static xToY(points: Point2d[]): Point2d[] {
+    let rval: Point2d[] = null;
+    if (Ratchet2d.validPoints(points)) {
+      rval = points.map((p) => {
+        const next: Point2d = { x: p.y, y: p.x };
+        return next;
+      });
+    }
+    return rval;
+  }
+
+  public static translate(points: Point2d[], xlate: Point2d): Point2d[] {
+    let rval: Point2d[] = null;
+    if (Ratchet2d.validPoints(points) && Ratchet2d.validPoint(xlate)) {
+      rval = Ratchet2d.applyTransform(points, MatrixFactory.translate(xlate.x, xlate.y));
+    }
+    return rval;
+  }
+
+  public static mirrorPointsOnPlane(points: Point2d[], src: Plane2d, mirrorX: boolean, mirrorY: boolean): Point2d[] {
+    let rval: Point2d[] = null;
+    if (Ratchet2d.validPoints(points) && Ratchet2d.validPlane(src)) {
+      if (mirrorX || mirrorY) {
+        rval = points.map((p) => {
+          const next: Point2d = {
+            x: mirrorX ? src.width - 1 - p.x : p.x,
+            y: mirrorY ? src.height - 1 - p.y : p.y,
+          };
+          return next;
+        });
+      } else {
+        // If not mirroring in either direction, then just copy
+        rval = Object.assign([], points);
+      }
+    }
+    return rval;
+  }
+
+  public static matchingVerticalOrientation(pt1: Plane2dType, pt2: Plane2dType): boolean {
+    return ((pt1===Plane2dType.BottomRight || pt1===Plane2dType.BottomLeft) && (pt2===Plane2dType.BottomRight || pt2===Plane2dType.BottomLeft)) ||
+      ((pt1===Plane2dType.TopLeft || pt1===Plane2dType.TopRight) && (pt2===Plane2dType.TopLeft || pt2===Plane2dType.TopRight));
+  }
+
+  public static matchingHorizontalOrientation(pt1: Plane2dType, pt2: Plane2dType): boolean {
+    return ((pt1===Plane2dType.BottomRight || pt1===Plane2dType.TopRight) && (pt2===Plane2dType.BottomRight || pt2===Plane2dType.TopRight)) ||
+      ((pt1===Plane2dType.BottomLeft || pt1===Plane2dType.TopLeft) && (pt2===Plane2dType.BottomLeft || pt2===Plane2dType.TopLeft));
+  }
+
+  public static transformPointsToNewPlane(points: Point2d[], src: Plane2d, dst: Plane2d): Point2d[] {
+    let rval: Point2d[] = null;
+    if (Ratchet2d.validPoints(points) && Ratchet2d.validPlane(src) && Ratchet2d.validPlane(dst)) {
+      const scale: Point2d = Ratchet2d.scaleVector(src, dst);
+      rval = Ratchet2d.applyTransform(points, MatrixFactory.scale(scale.x, scale.y));
+      rval = Ratchet2d.mirrorPointsOnPlane(rval, dst, !Ratchet2d.matchingHorizontalOrientation(src.type, dst.type), !Ratchet2d.matchingVerticalOrientation(src.type, dst.type));
+    }
+    return rval;
+  }
+
+  public static transformPointToNewPlane(point: Point2d, src: Plane2d, dst: Plane2d): Point2d {
+    const tmp: Point2d[] = Ratchet2d.transformPointsToNewPlane([point], src, dst);
+    return tmp.length === 1 ? tmp[0] : null;
+  }
+
+  public static transformLines(_lines: Line2d[], _src: Plane2d, _dst: Plane2d): Line2d[] {
+    return null;
+  }
+
+  // Given a set of points defining a curve, and a particular X, find the "best" Y
+  // for the curve defined by the points
+  public static fitCurve(curveDef: Point2d[], inputX: number): number {
+    curveDef.sort((a, b) => {
+      return a.x - b.x;
+    });
+
+    if (inputX <= curveDef[0].x) {
+      return curveDef[0].y;
+    } else if (inputX >= curveDef[curveDef.length - 1].x) {
+      return curveDef[curveDef.length - 1].y;
+    } else {
+      let idx = 0;
+      while (curveDef[idx + 1].x < inputX) {
+        idx++;
+      }
+      const xSpread: number = curveDef[idx + 1].x - curveDef[idx].x;
+      const ySpread: number = curveDef[idx + 1].y - curveDef[idx].y;
+      const pct: number = (inputX - curveDef[idx].x) / xSpread;
+      const yAdd: number = pct * ySpread;
+      return curveDef[idx].y + yAdd;
+    }
+  }
+
+  public static midPoint(src: Point2d, other: Point2d): Point2d {
+    return Ratchet2d.pointAtPercentDistance(src, other, 0.5);
+  }
+
+  public static pointAtPercentDistance(src: Point2d, other: Point2d, percent: number): Point2d {
+    if (percent < 0 || percent > 1) {
+      throw ErrorRatchet.fErr('Percent must be between 0 and 1, but was %d', percent);
+    }
+
+    const deltaX: number = other.x - src.x;
+    const deltaY: number = other.y - src.y;
+    return { x: src.x + deltaX * percent, y: src.y + deltaY * percent };
+  }
+
+  public static validatePoint(pt: Point2d): void {
+    RequireRatchet.notNullOrUndefined(pt, 'pt');
+    RequireRatchet.notNullOrUndefined(pt.x, 'pt.x');
+    RequireRatchet.notNullOrUndefined(pt.y, 'pt.y');
+  }
+
+  public static validateMatrix(tx: TransformationMatrix, includeUV?: boolean): void {
+    RequireRatchet.notNullOrUndefined(tx, 'tx');
+    RequireRatchet.notNullOrUndefined(tx.a, 'tx.a');
+    RequireRatchet.notNullOrUndefined(tx.b, 'tx.b');
+    RequireRatchet.notNullOrUndefined(tx.c, 'tx.c');
+    RequireRatchet.notNullOrUndefined(tx.d, 'tx.d');
+    if (includeUV) {
+      RequireRatchet.notNullOrUndefined(tx.u, 'tx.u');
+      RequireRatchet.notNullOrUndefined(tx.v, 'tx.v');
+    }
+  }
+
+  public static applyTransform(pt: Point2d[], tx: TransformationMatrix): Point2d[] {
+    const rval: Point2d[] = pt?.length ? pt.map(p=>Ratchet2d.applyTransformSingle(p, tx)) : pt;
+    return rval;
+  }
+
+  public static applyTransformSingle(pt: Point2d, tx: TransformationMatrix): Point2d {
+    Ratchet2d.validatePoint(pt);
+    Ratchet2d.validateMatrix(tx);
+
+    // Not a generalized matrix multiplier, although that's probably better.  Use math.js for that :P
+    const rval : Point2d = {
+      x: (tx.a * pt.x) + (tx.b * pt.y) + (tx.u | 0),
+      y: (tx.c * pt.x) + (tx.d * pt.y) + (tx.v | 0)
+    }
+    return rval;
+
+  }
+
+}