@dra2020/baseclient 1.0.12 → 1.0.13

package/lib/poly/polybin.ts

@@ -1,218 +0,0 @@
-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

@@ -1,204 +0,0 @@
-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;
-}