@dra2020/baseclient 1.0.0

package/lib/poly/polybin.ts

@@ -0,0 +1,218 @@
+import * as Util from '../util/all';
+import * as PP from './polypack';
+import * as T from './topo';
+
+// Packed Buffer format:
+//
+//  (strings are packed as UTF8 bytes, padded to 4 byte boundary)
+//
+//  { 4 byte size (byte offset to packed coordinate buffer) }
+//  { 4 byte length: property name,
+//    4 byte length: json string }*
+//  { 4 byte length: 'features' }
+//  { 4 byte length: length of 'features' array }
+//    { 4 byte length: property name,
+//      4 byte length: json string }*
+//  { padding to 8 byte boundary }
+//  { packed buffer coordinates in polypack format (indexed by geometry.packed above) }
+//
+
+const MagicInt = 17;
+const MagicFloat = 17.17;
+
+function pad(n: number, pad: number): number
+{
+  let mod = n % pad;
+  return mod ? pad - mod : 0;
+}
+
+function sizeOfString(coder: Util.Coder, s: string): number
+{
+  let s8 = Util.s2u8(coder, s);
+  return 4 + s8.length + pad(s8.length, 4);
+}
+
+function packString(coder: Util.Coder, buf8: Uint8Array, buf32: Int32Array, offset: number, s: string): number
+{
+  let s8 = Util.s2u8(coder, s);
+  buf32[offset >> 2] = s8.length;
+  offset += 4;
+  let i: number;
+  for (i = 0; i < s8.length; i++) buf8[offset++] = s8[i];
+  offset += pad(offset, 4);
+  return offset;
+}
+
+function unpackString(coder: Util.Coder, buf8: Uint8Array, buf32: Int32Array, offset: number): string
+{
+  let size = buf32[offset >> 2];
+  let s = Util.u82s(coder, buf8, offset+4, size);
+  return s;
+}
+
+export function packCollection(coder: Util.Coder, col: any): ArrayBuffer
+{
+  // Compute size
+  let pp = PP.featurePack(col) as PP.PolyPack;
+  let buffer: any = col.features.length ? col.features[0].geometry.packed.buffer : null;  // to restore, below
+  let size = 16; // int endiness, offset to coordinates, float endiness
+  col.features.forEach((f: any) => { delete f.geometry.packed.buffer; }); // reconstructed when unpacking
+  let j = JSON.stringify(col);
+  size += sizeOfString(coder, j);
+  size += pad(size, 8);
+  let fullsize = size + pp.length * 8;  // add space for coordinates
+
+  // Now pack it
+  let ab = new ArrayBuffer(fullsize);
+  let buf8 = new Uint8Array(ab);
+  let buf32 = new Int32Array(ab);
+  let buf64 = new Float64Array(ab);
+  let offset = 0;
+  buf32[0] = MagicInt;
+  offset += 4;
+  buf32[1] = size;
+  offset += 4;
+  buf64[1] = MagicFloat;  // Note that buf64[0] has the two ints stored above
+  offset += 8;
+  offset = packString(coder, buf8, buf32, offset, j);
+  offset += pad(offset, 8);
+  if (offset != size)
+    throw 'Oops, packing error.';
+  let foff = offset >> 3;
+  let buf = pp.buffer as Float64Array;
+  for (let i: number = 0; i < pp.length; i++)
+    buf64[foff++] = buf[i];
+
+  // Now restore
+  col.features.forEach((f: any) => { f.geometry.packed.buffer = buffer; });
+  PP.featureUnpack(col);
+
+  return ab;
+}
+
+function reverse(buf8: Uint8Array, s: number, n: number): void
+{
+  let e = s + n - 1;
+  while (s < e)
+  {
+    let t = buf8[s];
+    buf8[s] = buf8[e];
+    buf8[e] = t;
+    s++, e--;
+  }
+}
+
+function enforceEndianness(ab: ArrayBuffer): void
+{
+  let buf8 = new Uint8Array(ab);
+  let buf32 = new Int32Array(ab);
+  let buf64 = new Float64Array(ab);
+  let reverseInts = false;
+  if (buf32[0] != MagicInt)
+  {
+    reverseInts = true;
+    reverse(buf8, 0, 4);
+    if (buf32[0] != MagicInt) throw 'unpackCollection: badly formatted buffer';
+    reverse(buf8, 4, 4);  // size of non-floats
+  }
+  let reverseFloats = false;
+  if (buf64[1] != MagicFloat)
+  {
+    reverseFloats = true;
+    reverse(buf8, 8, 8);
+    if (buf64[1] != MagicFloat) throw 'unpackCollection: badly formatted buffer';
+  }
+  if (reverseInts)
+    reverse(buf8, 16, 4); // JSON string length
+  if (reverseFloats)
+  {
+    let s = buf32[1];  // Offset to floats
+    let e = ab.byteLength;
+    for (; s < e; s += 8)
+      reverse(buf8, s, 8);
+  }
+}
+
+export function unpackCollection(coder: Util.Coder, ab: ArrayBuffer): any
+{
+  enforceEndianness(ab);
+  let col: any = {};
+  let buf8 = new Uint8Array(ab);
+  let buf32 = new Int32Array(ab);
+  let size = buf32[1];
+  let buf64 = new Float64Array(ab, size); // offset to start of packed coordinates
+  let offset = 16;
+  let j = unpackString(coder, buf8, buf32, offset);
+  col = JSON.parse(j);
+  col.features.forEach((f: any) => { f.geometry.packed.buffer = buf64 });
+  return col;
+}
+
+// Format of packed buffer:
+//  [Size of JSON string] [4 bytes]
+//  [Size of packedarcs]  [4 bytes]
+//  [Size of packedarcindices]  [4 bytes]
+//  [padding] [4 bytes]
+//  [JSON string]
+//    [pad to 8]
+//  [packedarcs]
+//  [packedarcindices]
+
+const HeaderSize = 16;  // 4 Int32's 
+
+export function topoToBuffer(coder: Util.Coder, topo: any): ArrayBuffer
+{
+  // Make sure we're packed
+  T.topoPack(topo);
+  let savepack = topo.packed;
+  delete topo.packed;
+  let json = JSON.stringify(topo);
+  let byteLength = HeaderSize;  // 3 lengths + padding
+  let stringLength = sizeOfString(coder, json);
+  stringLength += pad(stringLength, 8);
+  byteLength += stringLength;
+  byteLength += savepack.arcs.byteLength;
+  byteLength += savepack.arcindices.byteLength;
+  let ab = new ArrayBuffer(byteLength);
+  let buf8 = new Uint8Array(ab);
+  let buf32 = new Int32Array(ab);
+  let buf64 = new Float64Array(ab, HeaderSize + stringLength, savepack.arcs.length);
+
+  buf32[0] = stringLength;
+  buf32[1] = savepack.arcs.byteLength;
+  buf32[2] = savepack.arcindices.byteLength;
+  buf32[3] = 0;
+  packString(coder, buf8, buf32, HeaderSize, json); json = null;
+  let af = savepack.arcs as Float64Array;
+  let n = af.length;
+  let i = 0;
+  let j = 0;
+  while (i < n)
+    buf64[j++] = af[i++];
+  let ai = savepack.arcindices as Int32Array;
+  n = ai.length;
+  i = 0;
+  j = (HeaderSize + stringLength + savepack.arcs.byteLength) / 4;
+  while (i < n)
+    buf32[j++] = ai[i++];
+
+  // restore
+  topo.packed = savepack;
+
+  return ab;
+}
+
+export function topoFromBuffer(coder: Util.Coder, ab: ArrayBuffer): any
+{
+  let buf8 = new Uint8Array(ab);
+  let buf32 = new Int32Array(ab);
+  let stringLength = buf32[0];
+  let arcsByteLength = buf32[1];
+  let arcindicesByteLength = buf32[2];
+  let json = unpackString(coder, buf8, buf32, HeaderSize);
+  let topo = JSON.parse(json);
+  topo.packed = {};
+  topo.packed.arcs = new Float64Array(ab, stringLength + HeaderSize, arcsByteLength / 8);
+  topo.packed.arcindices = new Int32Array(ab, stringLength + HeaderSize + arcsByteLength, arcindicesByteLength / 4);
+  return topo;
+}

package/lib/poly/polylabel.ts

@@ -0,0 +1,204 @@
+import TinyQueue from 'tinyqueue';
+import * as Util from '../util/all';
+import * as P from './poly';
+import * as PP from './polypack';
+import * as BB from './boundbox';
+
+interface PolyLabelResult
+{
+  x: number;
+  y: number;
+  d: number;
+}
+
+//
+// polyLabel: given polygon, return contained point furthest from any edge, and that distance
+//
+
+export function polyLabel(poly: any, precision?: number, debug?: boolean): PolyLabelResult
+{
+  let pp = P.polyNormalize(poly);
+  if (pp == null) return { x: 0, y: 0, d: 0 };
+
+  // For multi-polygon, pick largest polygon
+  let iLargest: number;
+  let nLargestArea: number;
+  PP.polyPackEachRing(pp, (b: Float64Array, iPoly: number, iRing: number, iOffset: number, nPoints: number) => {
+      if (iRing) return;
+      let nArea = P.polySimpleArea(b, iOffset, nPoints);
+      if (iLargest === undefined || nArea > nLargestArea) { iLargest = iPoly, nLargestArea = nArea }
+    });
+
+  if (iLargest === undefined)
+    return { x: 0, y: 0, d: 0 };
+
+  precision = precision || 0.00001;
+
+  let forEachPoint = (iter: any) => {
+      PP.polyPackEachPoint(pp, (b: Float64Array, iPoly: number, iRing: number, iOffset: number) => {
+          if (iPoly != iLargest || iRing) return;
+          iter(b[iOffset], b[iOffset+1]);
+        });
+    };
+  let forEachPointPair = (iter: any) => {
+      PP.polyPackEachRing(pp, (b: Float64Array, iPoly, iRing: number, iOffset: number, nPoints: number) => {
+          if (iPoly != iLargest || iRing) return;
+          let iFirst = iOffset;
+          let iLast = iOffset + nPoints * 2;
+          let iSecond = iLast - 2;
+          for (; iFirst < iLast; iSecond = iFirst, iFirst += 2)
+            iter(b[iFirst], b[iFirst+1], b[iSecond], b[iSecond+1]);
+        });
+    };
+
+  // find the bounding box of the outer ring
+  let minX: number, minY: number, maxX: number, maxY: number;
+  forEachPoint((x: number, y: number) => {
+      if (minX === undefined || x < minX) minX = x;
+      if (minY === undefined || y < minY) minY = y;
+      if (maxX === undefined || x > maxX) maxX = x;
+      if (maxY === undefined || y > maxY) maxY = y;
+    });
+
+  let width: number = maxX - minX;
+  let height: number = maxY - minY;
+  let cellSize: number = Math.min(width, height);
+  let h: number = cellSize / 2;
+
+  if (cellSize === 0) return { x: minX, y: minY, d: 0 };
+
+  // a priority queue of cells in order of their "potential" (max distance to polygon)
+  let cellQueue = new TinyQueue<Cell>(undefined, compareMax);
+
+  // cover polygon with initial cells
+  for (let x: number = minX; x < maxX; x += cellSize)
+  {
+    for (let y: number = minY; y < maxY; y += cellSize)
+      cellQueue.push(new Cell(x + h, y + h, h, forEachPointPair));
+  }
+
+  // take centroid as the first best guess
+  let bestCell: any = getCentroidCell(forEachPointPair);
+
+  // special case for rectangular polygons
+  let bboxCell: Cell = new Cell(minX + width / 2, minY + height / 2, 0, forEachPointPair);
+  if (bboxCell.d > bestCell.d) bestCell = bboxCell;
+
+  let numProbes = cellQueue.length;
+
+  while (cellQueue.length)
+  {
+    // pick the most promising cell from the queue
+    let cell = cellQueue.pop();
+
+    // update the best cell if we found a better one
+    if (cell.d > bestCell.d)
+    {
+      bestCell = cell;
+      if (debug) console.log('found best %d after %d probes', Math.round(1e4 * cell.d) / 1e4, numProbes);
+    }
+
+    // do not drill down further if there's no chance of a better solution
+    if (cell.max - bestCell.d <= precision) continue;
+
+    // split the cell into four cells
+    h = cell.h / 2;
+    cellQueue.push(new Cell(cell.x - h, cell.y - h, h, forEachPointPair));
+    cellQueue.push(new Cell(cell.x + h, cell.y - h, h, forEachPointPair));
+    cellQueue.push(new Cell(cell.x - h, cell.y + h, h, forEachPointPair));
+    cellQueue.push(new Cell(cell.x + h, cell.y + h, h, forEachPointPair));
+    numProbes += 4;
+  }
+
+  if (debug)
+  {
+    console.log('num probes: ' + numProbes);
+    console.log('best distance: ' + bestCell.d);
+  }
+
+  return { x: bestCell.x, y: bestCell.y, d: bestCell.d };
+}
+
+function compareMax(a: Cell, b: Cell) { return b.max - a.max; }
+
+class Cell
+{
+  x: number;
+  y: number;
+  h: number;
+  d: number;
+  max: number;
+
+  constructor(x: number, y: number, h: number, forEachPointPair: any)
+  {
+    this.x = x; // cell center x
+    this.y = y; // cell center y
+    this.h = h; // half the cell size
+    this.d = pointToPolygonDist(x, y, forEachPointPair); // distance from cell center to polygon
+    this.max = this.d + this.h * Math.SQRT2; // max distance to polygon within a cell
+  }
+}
+
+// signed distance from point to polygon outline (negative if point is outside)
+function pointToPolygonDist(x: number, y: number, forEachPointPair: any): number
+{
+  let inside: boolean = false;
+  let minDistSq: number = Infinity;
+
+  forEachPointPair((ax: number, ay: number, bx: number, by: number) => {
+      if ((ay > y !== by > y) && (x < (bx - ax) * (y - ay) / (by - ay) + ax))
+        inside = !inside;
+
+      minDistSq = Math.min(minDistSq, getSegDistSq(x, y, ax, ay, bx, by));
+    });
+
+  return (inside ? 1 : -1) * Math.sqrt(minDistSq);
+}
+
+// get polygon centroid
+function getCentroidCell(forEachPointPair: any): Cell
+{
+  let area = 0;
+  let x = 0;
+  let y = 0;
+  let fx: number;
+  let fy: number;
+
+  forEachPointPair((ax: number, ay: number, bx: number, by: number) => {
+      if (fx === undefined) fx = ax, fy = ay;
+      let f: number = ax * by - bx * ay;
+      x += (ax + bx) * f;
+      y += (ay + by) * f;
+      area += f * 3;
+    });
+  if (area === 0) return new Cell(fx, fy, 0, forEachPointPair);
+  return new Cell(x / area, y / area, 0, forEachPointPair);
+}
+
+// get squared distance from a point to a segment
+function getSegDistSq(px: number, py: number, ax: number, ay: number, bx: number, by: number): number
+{
+  let dx = bx - ax;
+  let dy = by - ay;
+
+  if (dx !== 0 || dy !== 0)
+  {
+    let t: number = ((px - ax) * dx + (py - ay) * dy) / (dx * dx + dy * dy);
+
+    if (t > 1)
+    {
+      ax = bx;
+      ay = by;
+    }
+    else if (t > 0)
+    {
+      ax += dx * t;
+      ay += dy * t;
+    }
+  }
+
+  dx = px - ax;
+  dy = py - ay;
+
+  return dx * dx + dy * dy;
+}