@dra2020/baseclient 1.0.13 → 1.0.14

package/lib/poly/graham-scan.ts

@@ -0,0 +1,401 @@
+//
+// CONVEX HULL USING GRAHAM SCAN ALGORITHM
+//
+/* Resources:
+ * https://en.wikipedia.org/wiki/Graham_scan
+ * https://www.tutorialspoint.com/Graham-Scan-Algorithm <<< pseudo code
+ * http://brian3kb.github.io/graham_scan_js/ <<< basis for this implementation
+ */
+
+import {polyNormalize, PolyOptions} from './poly';
+import * as PP from './polypack';
+
+type SimplePoint = [number, number];
+
+
+export function makeConvexHullGrahamScan(poly: any, options?: PolyOptions): any
+{
+  let points = getExteriorPoints(poly);
+  if (points == null) return null;
+
+  let scanner = new GrahamScanner();
+
+  for (let pt of points) {
+    scanner.addPoint(pt);
+  }
+
+  const ch: SimplePoint[] = scanner.getHull();
+
+  return [ ch ];
+}
+
+// NOTE - This finds the exterior points of a polygon in standard form and returns
+//   it as an array if [x, y] points, in contrast to polyToExteriorPoints() which
+//   uses the packed format and the poly.ts-private point form.
+function getExteriorPoints(poly: any): SimplePoint[]
+{
+  let pp = polyNormalize(poly);
+  if (pp == null) return null;
+
+  let points: SimplePoint[] = [];
+
+  PP.polyPackEachPoint(pp, (b: Float64Array, iPoly: number, iRing: number, iOffset: number) => {
+      if (iRing > 0) return;  // skip holes
+      points.push([b[iOffset], b[iOffset+1]]);
+    });
+
+  return points.length > 0 ? points : null;
+}
+
+const X = 0, Y = 1;
+
+class GrahamScanner
+{
+  anchorPoint: SimplePoint | undefined;
+  reverse: boolean;
+  points: SimplePoint[];
+
+  constructor()
+  {
+    this.anchorPoint = undefined;
+    this.reverse = false;
+    this.points = [];
+  }
+  _findPolarAngle(a: SimplePoint, b: SimplePoint): number
+  {
+    const ONE_RADIAN = 57.295779513082;
+    let deltaX, deltaY;
+
+    // If the points are undefined, return a zero difference angle.
+    if (!a || !b) return 0;
+
+    deltaX = (b[X] - a[X]);
+    deltaY = (b[Y] - a[Y]);
+
+    if (deltaX == 0 && deltaY == 0) {
+        return 0;
+    }
+
+    let angle = Math.atan2(deltaY, deltaX) * ONE_RADIAN;
+
+    if (this.reverse) {
+      if (angle <= 0) {
+          angle += 360;
+      }
+    }
+    else
+    {
+      if (angle >= 0) {
+          angle += 360;
+      }
+    }
+
+    return angle;
+  }
+  addPoint(pt: SimplePoint): void
+  {
+    // Check for a new anchor
+    const newAnchor =
+        ( this.anchorPoint === undefined ) ||
+        ( this.anchorPoint[Y] > pt[Y] ) ||
+        ( this.anchorPoint[Y] === pt[Y] && this.anchorPoint[X] > pt[X] );
+
+    if ( newAnchor ) {
+      if ( this.anchorPoint !== undefined ) {
+          this.points.push(pt);
+      }
+      this.anchorPoint = pt;
+    }
+    else
+    {
+      this.points.push(pt);
+    }
+  }
+  _sortPoints(): SimplePoint[] 
+  {
+    var self = this;
+
+    return this.points.sort(function(a: SimplePoint, b: SimplePoint) 
+    {
+      const polarA = self._findPolarAngle(self.anchorPoint as SimplePoint, a);
+      const polarB = self._findPolarAngle(self.anchorPoint as SimplePoint, b);
+    
+      if (polarA < polarB) {
+          return -1;
+      }
+      if (polarA > polarB) {
+          return 1;
+      }
+    
+      return 0;
+    });
+  }
+  _checkPoints(p0: SimplePoint, p1: SimplePoint, p2: SimplePoint): boolean 
+  {
+    let difAngle;
+    const cwAngle = this._findPolarAngle(p0, p1);
+    const ccwAngle = this._findPolarAngle(p0, p2);
+
+    if (cwAngle > ccwAngle) {
+      difAngle = cwAngle - ccwAngle;
+
+      return !(difAngle > 180);
+    }
+    else if (cwAngle < ccwAngle)
+    {
+      difAngle = ccwAngle - cwAngle;
+
+      return (difAngle > 180);
+    }
+
+    return true;
+  }
+  getHull(): SimplePoint[] 
+  {
+    let hullPoints: SimplePoint[] = [];
+    let points: SimplePoint[];
+    let pointsLength: number;
+
+    this.reverse = this.points.every(
+      function (point)
+      {
+        return (point[X] < 0 && point[Y] < 0);
+      }
+    );
+
+    points = this._sortPoints();
+    pointsLength = points.length;
+
+    // If there are less than 3 points, joining these points creates a correct hull.
+    if (pointsLength < 3) {
+        points.unshift(this.anchorPoint as SimplePoint);
+        return points;
+    }
+
+    // Move first two points to output array
+    const first: SimplePoint = points.shift() as SimplePoint;
+    const second: SimplePoint = points.shift() as SimplePoint;
+    hullPoints.push(first, second);
+
+    // Scan is repeated until no concave points are present.
+    while (true) {
+      let p0: SimplePoint;
+      let p1: SimplePoint;
+      let p2: SimplePoint;
+
+      hullPoints.push(points.shift() as SimplePoint);
+
+      p0 = hullPoints[hullPoints.length - 3];
+      p1 = hullPoints[hullPoints.length - 2];
+      p2 = hullPoints[hullPoints.length - 1];
+
+      if (this._checkPoints(p0, p1, p2)) {
+          hullPoints.splice(hullPoints.length - 2, 1);
+      }
+
+      if (points.length == 0) 
+      {
+        if (pointsLength == hullPoints.length) 
+        {
+          // Check for duplicate anchorPoint edge-case, if not found, add the anchorpoint as the first item.
+          const ap: SimplePoint = this.anchorPoint as SimplePoint;
+          // Remove any udefined elements in the hullPoints array.
+          hullPoints = hullPoints.filter(function(p) { return !!p; });
+          if (!hullPoints.some(function(p){
+                  return(p[X] == ap[X] && p[Y] == ap[Y]);
+              })) {
+              hullPoints.unshift(this.anchorPoint as SimplePoint);
+          }
+          return hullPoints;
+        }
+        points = hullPoints;
+        pointsLength = points.length;
+        hullPoints = [];
+        const first: SimplePoint = points.shift() as SimplePoint;
+        const second: SimplePoint = points.shift() as SimplePoint;
+        hullPoints.push(first, second);
+      }
+    }
+  }
+}
+
+/**
+ * Graham's Scan Convex Hull Algorithm
+ * @desc An implementation of the Graham's Scan Convex Hull algorithm in JavaScript.
+ * @author Brian Barnett, brian@3kb.co.uk, http://brianbar.net/ || http://3kb.co.uk/
+ * @version 1.0.5
+ */
+
+/*
+function ConvexHullGrahamScan() {
+  this.anchorPoint = undefined;
+  this.reverse = false;
+  this.points = [];
+}
+
+ConvexHullGrahamScan.prototype = {
+
+  constructor: ConvexHullGrahamScan,
+
+  Point: function (x, y) {
+      this.x = x;
+      this.y = y;
+  },
+
+  _findPolarAngle: function (a, b) {
+      var ONE_RADIAN = 57.295779513082;
+      var deltaX, deltaY;
+
+      //if the points are undefined, return a zero difference angle.
+      if (!a || !b) return 0;
+
+      deltaX = (b.x - a.x);
+      deltaY = (b.y - a.y);
+
+      if (deltaX == 0 && deltaY == 0) {
+          return 0;
+      }
+
+      var angle = Math.atan2(deltaY, deltaX) * ONE_RADIAN;
+
+      if (this.reverse){
+          if (angle <= 0) {
+              angle += 360;
+          }
+      }else{
+          if (angle >= 0) {
+              angle += 360;
+          }
+      }
+
+      return angle;
+  },
+
+  addPoint: function (x, y) {
+      //Check for a new anchor
+      var newAnchor =
+          (this.anchorPoint === undefined) ||
+          ( this.anchorPoint.y > y ) ||
+          ( this.anchorPoint.y === y && this.anchorPoint.x > x );
+
+      if ( newAnchor ) {
+          if ( this.anchorPoint !== undefined ) {
+              this.points.push(new this.Point(this.anchorPoint.x, this.anchorPoint.y));
+          }
+          this.anchorPoint = new this.Point(x, y);
+      } else {
+          this.points.push(new this.Point(x, y));
+      }
+  },
+
+  _sortPoints: function () {
+      var self = this;
+
+      return this.points.sort(function (a, b) {
+          var polarA = self._findPolarAngle(self.anchorPoint, a);
+          var polarB = self._findPolarAngle(self.anchorPoint, b);
+
+          if (polarA < polarB) {
+              return -1;
+          }
+          if (polarA > polarB) {
+              return 1;
+          }
+
+          return 0;
+      });
+  },
+
+  _checkPoints: function (p0, p1, p2) {
+      var difAngle;
+      var cwAngle = this._findPolarAngle(p0, p1);
+      var ccwAngle = this._findPolarAngle(p0, p2);
+
+      if (cwAngle > ccwAngle) {
+
+          difAngle = cwAngle - ccwAngle;
+
+          return !(difAngle > 180);
+
+      } else if (cwAngle < ccwAngle) {
+
+          difAngle = ccwAngle - cwAngle;
+
+          return (difAngle > 180);
+
+      }
+
+      return true;
+  },
+
+  getHull: function () {
+      var hullPoints = [],
+          points,
+          pointsLength;
+
+      this.reverse = this.points.every(function(point){
+          return (point.x < 0 && point.y < 0);
+      });
+
+      points = this._sortPoints();
+      pointsLength = points.length;
+
+      //If there are less than 3 points, joining these points creates a correct hull.
+      if (pointsLength < 3) {
+          points.unshift(this.anchorPoint);
+          return points;
+      }
+
+      //move first two points to output array
+      hullPoints.push(points.shift(), points.shift());
+
+      //scan is repeated until no concave points are present.
+      while (true) {
+          var p0,
+              p1,
+              p2;
+
+          hullPoints.push(points.shift());
+
+          p0 = hullPoints[hullPoints.length - 3];
+          p1 = hullPoints[hullPoints.length - 2];
+          p2 = hullPoints[hullPoints.length - 1];
+
+          if (this._checkPoints(p0, p1, p2)) {
+              hullPoints.splice(hullPoints.length - 2, 1);
+          }
+
+          if (points.length == 0) {
+              if (pointsLength == hullPoints.length) {
+                  //check for duplicate anchorPoint edge-case, if not found, add the anchorpoint as the first item.
+                  var ap = this.anchorPoint;
+                  //remove any udefined elements in the hullPoints array.
+                  hullPoints = hullPoints.filter(function(p) { return !!p; });
+                  if (!hullPoints.some(function(p){
+                          return(p.x == ap.x && p.y == ap.y);
+                      })) {
+                      hullPoints.unshift(this.anchorPoint);
+                  }
+                  return hullPoints;
+              }
+              points = hullPoints;
+              pointsLength = points.length;
+              hullPoints = [];
+              hullPoints.push(points.shift(), points.shift());
+          }
+      }
+  }
+};
+
+// EXPORTS
+
+if (typeof define === 'function' && define.amd) {
+  define(function() {
+      return ConvexHullGrahamScan;
+  });
+}
+if (typeof module !== 'undefined') {
+  module.exports = ConvexHullGrahamScan;
+}
+
+*/

package/lib/poly/hash.ts

@@ -0,0 +1,15 @@
+import * as objectHash from 'object-hash';
+
+export function qhash(o: any, keys?: any): any
+{
+  // Copy only specified keys into temp object if subset provided.
+  if (keys !== undefined)
+  {
+    let tmpO: any = {};
+    for (let p in keys) if (keys.hasOwnProperty(p))
+      tmpO[p] = o[p];
+    o = tmpO;
+  }
+
+  return objectHash(o, { unorderedArrays: true, unorderedSets: true, });
+}

package/lib/poly/matrix.ts

@@ -0,0 +1,309 @@
+//
+// SOME BASIC MATRIX OPERATIONS FOR MBR
+//
+
+/* 
+
+These custom functions are used by minimumBoundingRectangle(), instead of the
+same-named mathjs versions. They are tailored specifically for that routine and
+are NOT intended for general use.
+
+export declare function matrix(x: Matrix): Matrix;
+
+export declare function multiply(a: Matrix, b: Matrix): Matrix;
+
+export declare function transpose(a: Matrix, b: Matrix): Matrix;
+
+export declare function apply((a: Matrix, over: Dim, cb: applyCB): Vector;
+
+export declare function min(a: Vector): number;
+
+export declare function max(a: Vector): number;
+
+export declare function concat(a: Matrix, b: Matrix, by: Dim): Matrix;
+
+export declare function row(a: Matrix, i: number): Vector;
+
+export declare function subtract(a: Vector, b: Vector): Vector;
+
+export declare function dotMultiply(a: Vector, b: Vector): Vector;
+
+export declare function index(a: Range, b: Range): Index;
+
+export declare function range(start: number, end: number, includeEnd: boolean = false): Vector;
+
+export declare function subset(a: Matrix, select: Index): Matrix;
+
+*/
+
+
+export type Matrix = number[][];
+export type Vector = number[];                // A general vector or a row or a column
+export type Range = number[];
+export type Index = number[][];
+export type applyCB = (v: Vector) => number;
+
+export const enum Dim
+{
+  Rows,
+  Columns
+}
+
+export function matrix(a: Matrix): Matrix
+{
+  return a;
+}
+
+export function multiply(a: Matrix, b: Matrix): Matrix
+{
+  protect((nRows(a) > 0), "In multiply, input matrix 'a' has no rows. ");
+  protect((nCols(a) > 0), "In multiply, input matrix 'a' has no columns. ");
+  protect((nRows(b) > 0), "In multiply, input matrix 'b' has no rows. ");
+  protect((nCols(b) > 0), "In multiply, input matrix 'b' has no columns. ");
+
+  const m = nRows(a);
+  const n = nCols(a);
+  const p = nRows(b);
+  const q = nCols(b);
+
+  protect((p == n), "In multiply, the # rows in matrix 'b' doesn't match the number of columns in matrix 'a'.");
+
+  let c: Matrix = initialize(m, n);
+
+  for (let i = 0; i < m; i++)
+  {
+    for (let j = 0; j < q; j++)
+    {
+      const aRow = row(a, i);
+      const bCol = column(b, j);
+
+      c[i][j] = dotProduct(aRow, bCol);
+    }
+  }
+
+  return c;
+}
+
+export function transpose(a: Matrix): Matrix
+{
+  protect((nRows(a) > 0), "In transpose, input matrix has no rows. ");
+  protect((nCols(a) > 0), "In transpose, input matrix has no columns. ");
+
+  const j = nRows(a);
+  const i = nCols(a);
+
+  let b: Matrix = initialize(i, j);
+
+  for (let m = 0; m < j; m++)
+  {
+    for (let n = 0; n < i; n++)
+    {
+      b[n][m] = a[m][n];
+    }
+  }
+
+  return b;
+}
+
+export function apply(a: Matrix, over: Dim, cb: applyCB): Vector
+{
+  protect((nRows(a) > 0), "In apply, input matrix has no rows. ");
+  protect((nCols(a) > 0), "In apply, input matrix has no columns. ");
+
+  let m = nRows(a);
+  let n = nCols(a);
+
+  let result: Vector = [];
+
+  const iEnd = (over == Dim.Rows) ? m : n;
+  const extractFn = (over == Dim.Rows) ? row : column;
+
+  for (let i = 0; i < iEnd; i++)
+  {
+    const v: Vector = extractFn(a, i);
+    result.push(cb(v));
+  }
+
+  return result;
+}
+
+export function min(v: Vector): number
+{
+  return Math.min(...v);
+}
+
+export function max(v: Vector): number
+{
+  return Math.max(...v);
+}
+
+export function concat(a: Matrix, b: Matrix, by: Dim): Matrix
+{
+  protect((nRows(a) > 0), "In concat, input matrix 'a' has no rows. ");
+  protect((nCols(a) > 0), "In concat, input matrix 'a' has no columns. ");
+  protect((nRows(b) > 0), "In concat, input matrix 'b' has no rows. ");
+  protect((nCols(b) > 0), "In concat, input matrix 'b' has no columns. ");
+
+  let m = nRows(a);
+  let n = nCols(a);
+  const p = nRows(b);
+  const q = nCols(b);
+
+  const {i, j} = (by == Dim.Columns) ? {i: m, j: n + q} : {i: m + p, j: n};
+  let c: Matrix = initialize(i, j);
+
+  if (by == Dim.Rows)
+    protect((n == q), "In concat, concatenating rows but the # of columns don't match. ");
+  else // (by == Dim.Columns)
+    protect((m == p), "In concat, concatenating columns but the # of rows don't match. ");
+
+  // Copy the first array
+  for (let i = 0; i < m; i++)
+  {
+    for (let j = 0; j < n; j++)
+    {
+      c[i][j] = a[i][j];
+    }
+  }
+
+  m = (by == Dim.Rows) ? m : 0;
+  n = (by == Dim.Columns) ? n : 0;
+
+  // Copy the second array to the right (by columns) or below (by rows)
+  for (let i = 0; i < p; i++)
+  {
+    for (let j = 0; j < q; j++)
+    {
+      c[i+m][j+n] = b[i][j];
+    }
+  }
+
+  return c;
+}
+
+export function row(a: Matrix, i: number): Vector
+{
+  protect((nRows(a) > 0), "In row, input matrix has no rows. ");
+  protect((nCols(a) > 0), "In row, input matrix has no columns. ");
+  protect((i >= 0), "In row, invalid row index.");
+
+  return a[i];
+}
+
+export function column(a: Matrix, j: number): Vector
+{
+  protect((nRows(a) > 0), "In column, input matrix has no rows. ");
+  protect((nCols(a) > 0), "In column, input matrix has no columns. ");
+  protect((j >= 0), "In row, invalid column index.");
+
+  let v: any = [];
+
+  for (let i = 0; i < nRows(a); i++)
+  {
+    v.push(a[i][j]);
+  }
+
+  return v;
+}
+
+export function subtract(a: Vector, b: Vector): Vector
+{
+  protect((a.length == b.length), "In subtract, the input vectors have different lengths.");
+
+  let c: Vector = [];
+
+  for (let i = 0; i < a.length; i++)
+  {
+    c.push(a[i] - b[i]);
+  }
+
+  return c;
+}
+
+export function dotMultiply(a: Vector, b: Vector): Vector
+{
+  protect((a.length > 0) && (a.length == b.length), "In dotMultiply, the vectors aren't the same length. ");
+
+  let c: Vector = [];
+
+  for (let i = 0; i < a.length; i++)
+  {
+    c.push(a[i] * b[i]);
+  }
+
+  return c;
+}
+
+export function index(a: Range, b: Range): Index
+{
+  return [a, b];
+}
+
+export function range(start: number, end: number, includeEnd: boolean = false): Vector
+{
+  let r: Vector = [];
+
+  end += includeEnd ? 1 : 0;
+  for (let i = start; i < end; i++)
+  {
+    r.push(i);
+  }
+  
+  return r;
+}
+
+export function subset(a: Matrix, select: Index): Matrix
+{
+  protect((nRows(a) > 0), "In subset, input matrix has no rows. ");
+  protect((nCols(a) > 0), "In subset, input matrix has no columns. ");
+
+  protect((nRows(select) > 0), "In subset, input matrix has no rows. ");
+  protect((nCols(select) > 0), "In subset, input matrix has no columns. ");
+
+  const m = nRows(a);
+  const n = nCols(a);
+
+  const rowRange = row(select, 0) as Range;
+  const colRange = row(select, 1) as Range;
+  const p = rowRange.length;
+  const q = colRange.length;
+
+  let b: Matrix = initialize(p, q);
+
+  for (let i = 0; i < p; i++)
+  {
+    for (let j = 0; j < q; j++)
+    {
+      b[i][j] = a[rowRange[i]][colRange[j]];
+    }
+  }
+
+  return b;
+}
+
+
+// HELPERS
+
+function initialize(rows: number, cols: number): Matrix
+{
+  protect(((rows > 0) || (cols > 0)), "In initialize, the # of rows or columns is not positive. ");
+
+  return [...Array(rows)].fill(0).map(() => [...Array(cols)].fill(0));
+};
+
+const nRows = (a: Matrix | Index) => a.length;
+const nCols = (a: Matrix | Index) => (a.length > 0) ? a[0].length : 0;
+
+export function dotProduct(a: Vector, b: Vector): number
+{
+  protect((a.length > 0) && (a.length == b.length), "In dotProduct, the vectors aren't the same length. ");
+
+  return a.map((value, i) => value * b[i]).reduce((acc, val) => acc + val, 0);
+};
+
+
+function protect(condition: boolean, message: string): void
+{
+  if (!condition)
+    throw new Error(message);
+}