@dra2020/baseclient 1.0.13 → 1.0.14

package/lib/poly/quad.ts

@@ -0,0 +1,272 @@
+// Public libraries
+import * as PC from 'polygon-clipping';
+
+// Shared libraries
+import * as Util from '../util/all';
+import * as FSM from '../fsm/all';
+
+// Local libraries
+import * as Poly from './poly';
+import * as PP from './polypack';
+import * as BB from './boundbox';
+import * as PR from './polyround';
+
+let _union: any = undefined;
+let anyPC: any = PC;
+if (anyPC.union) _union = anyPC.union;
+if (anyPC.default && anyPC.default.union) _union = anyPC.default.union;
+if (_union === undefined) throw 'Unable to load union function from polygon-clipping';
+
+export interface WrappedPoly { box: BB.BoundBox, p: any };
+
+export interface WorkDone
+{
+  nUnion: number,
+  nDifference: number,
+  ms: number,
+}
+
+function featureCoords(feature: any): any
+{
+/*
+  if (feature.geometry !== undefined)
+  {
+    if (feature.geometry.packed !== undefined)
+      return PP.polyUnpack(feature.geometry.packed);
+    else
+      return feature.geometry.coordinates;
+  }
+  else if (feature.offset !== undefined)
+    return PP.polyUnpack(feature);
+  else
+    return feature;
+*/
+  if (feature.geometry !== undefined)
+  {
+    if (feature.geometry.packed !== undefined)
+      return feature.geometry.packed;
+    else
+      return feature.geometry.coordinates;
+  }
+  else
+    return feature;
+}
+
+// This function takes an array of packed or unpacked polygon/multipolygons and
+// returns an unpacked polygon/multipolygon coordinate array. Returns null if
+// handed an empty array.
+
+export function unionPolys(polys: any[]): any
+{
+  if (polys == null) return null;
+
+  let cleanPolys: any[] = polys.filter((f: any) => f != null);
+  if (cleanPolys.length == 0) return null;
+  if (cleanPolys.length == 1) return PP.polyUnpack(cleanPolys[0]);
+  cleanPolys = cleanPolys.map( (f: any) => PP.polyUnpack(f) );
+
+  let poly: any = cleanPolys.pop();
+  return PR.polyRound(_union(poly, ...cleanPolys));
+}
+
+export interface QuadOptions
+{
+  maxLeafCount?: number;
+  maxDepth?: number;
+  tickStep?: number;
+}
+export const DefaultQuadOptions: QuadOptions = { maxLeafCount: 20, maxDepth: 20, tickStep: 1 };
+
+export interface TickCounter { ticks: number };
+
+// Use geo orientation for t/b (that is, t > b)
+class QuadLevel
+{
+  options: QuadOptions;
+  level: number;
+  children: QuadLevel[];
+  features: any[];
+  box: BB.BoundBox;
+  asyncUnion: any;
+
+  constructor(options: QuadOptions, level: number, box: BB.BoundBox, features: WrappedPoly[])
+  {
+    this.options = options;
+    this.level = level;
+    this.box = box;
+    if (features.length <= options.maxLeafCount || this.level >= options.maxDepth)
+    {
+      if (this.level >= options.maxDepth)
+        throw `QuadTree: maximum depth of ${options.maxDepth} exceeded`;
+      this.features = features.map((wp: WrappedPoly) => wp.p);
+      this.children = null;
+    }
+    else
+    {
+      this.features = null;
+      let cx = BB.boundboxCX(box);
+      let cy = BB.boundboxCY(box);
+
+      let tl: BB.BoundBox = { left: box.left, top: box.top, right: cx, bottom: cy };
+      let tr: BB.BoundBox = { left: cx, top: box.top, right: box.right, bottom: cy };
+      let bl: BB.BoundBox = { left: box.left, top: cy, right: cx, bottom: box.bottom };
+      let br: BB.BoundBox = { left: cx, top: cy, right: box.right, bottom: box.bottom };
+      let tlFeatures = [];
+      let trFeatures = [];
+      let blFeatures = [];
+      let brFeatures = [];
+
+      for (let i: number = 0; i < features.length; i++)
+      {
+        let f = features[i];
+
+        if (this.featureInBox(tl, f))
+          tlFeatures.push(f);
+        else if (this.featureInBox(tr, f))
+          trFeatures.push(f);
+        else if (this.featureInBox(bl, f))
+          blFeatures.push(f);
+        else if (this.featureInBox(br, f))
+          brFeatures.push(f);
+      }
+      this.children = [];
+      this.children.push(new QuadLevel(options, level+1, tl, tlFeatures));
+      this.children.push(new QuadLevel(options, level+1, tr, trFeatures));
+      this.children.push(new QuadLevel(options, level+1, bl, blFeatures));
+      this.children.push(new QuadLevel(options, level+1, br, brFeatures));
+      this.asyncUnion = null;
+    }
+  }
+
+  private featureInBox(box: BB.BoundBox, f: WrappedPoly): boolean
+  {
+    return BB.boundboxIntersects(box, f.box);
+  }
+
+  union(): any
+  {
+    if (this.asyncUnion == null)
+    {
+      if (this.children == null)
+        this.asyncUnion = unionPolys(this.features);
+      else
+        this.asyncUnion = unionPolys(this.children.map((q: QuadLevel) => q.union()));
+    }
+    return this.asyncUnion;
+  }
+
+  get isempty(): boolean
+  {
+    return this.children == null && this.features.length == 0;
+  }
+
+  tickUnion(tickCounter: TickCounter): void
+  {
+    if (!this.isempty && this.asyncUnion == null)
+    {
+      if (this.children == null)
+      {
+        if (tickCounter.ticks != 0)
+        {
+          this.union();
+          tickCounter.ticks--;
+        }
+      }
+      else
+      {
+        for (let i: number = 0; i < this.children.length && tickCounter.ticks != 0; i++)
+          this.children[i].tickUnion(tickCounter);
+
+        // If tickCounter hasn't gone to zero, we fully computed children, go ahead and compute union here.
+        if (tickCounter.ticks != 0)
+        {
+          this.union();
+          tickCounter.ticks--;
+        }
+      }
+    }
+  }
+}
+
+export class FsmQuadTree extends FSM.Fsm
+{
+  quad: QuadLevel;
+  asyncUnion: any;
+  isempty: boolean;
+  options: Poly.TickOptions;
+  work: WorkDone;
+
+  constructor(env: FSM.FsmEnvironment, options?: Poly.TickOptions, col?: any)
+  {
+    super(env);
+    this.options = Util.shallowAssignImmutable(Poly.DefaultTickOptions, options);
+    this.work = { nUnion: 0, nDifference: 0, ms: 0 };
+    this.initialize(col);
+  }
+
+  initialize(col: any): void
+  {
+    this.quad = null;
+    this.asyncUnion = undefined;
+    this.isempty = true;
+
+    if (col != null)
+    {
+      let features: any = col.features ? col.features : col;
+      this.work.nUnion = features.length;
+      this.isempty = features.length == 0;
+
+      // Compute BoundBox for each feature
+      let wrapped: WrappedPoly[] = features.map((f: any) => { return { box: BB.boundbox(f), p: featureCoords(f) } });
+
+      let box = BB.boundbox(col);
+      this.quad = new QuadLevel(this.options, 0, box, wrapped);
+    }
+
+    this.setState(this.isempty ? FSM.FSM_DONE : FSM.FSM_STARTING);
+  }
+
+  cancel(): any
+  {
+    this.quad = null;
+    this.asyncUnion = undefined;
+    this.isempty = true;
+    this.setState(FSM.FSM_DONE);
+  }
+
+  get result(): any
+  {
+    if (this.asyncUnion === undefined && this.quad)
+      this.asyncUnion = this.quad.union();
+    return this.asyncUnion;
+  }
+
+  tick(): void
+  {
+    if (this.ready)
+    {
+      switch (this.state)
+      {
+        case FSM.FSM_STARTING:
+          this.setState(FSM.FSM_PENDING);
+          break;
+
+        case FSM.FSM_PENDING:
+          let tickCounter: TickCounter = { ticks: this.options.tickStep }
+          let elapsed = new Util.Elapsed();
+          if (!this.isempty && this.asyncUnion === undefined)
+          {
+            this.quad.tickUnion(tickCounter);
+            if (tickCounter.ticks != 0)
+              this.result;
+          }
+          this.work.ms += elapsed.ms();
+          if (this.asyncUnion !== undefined)
+            this.setState(FSM.FSM_DONE);
+          else
+            this.setState(FSM.FSM_PENDING);
+          break;
+      }
+    }
+  }
+}

package/lib/poly/selfintersect.ts

@@ -0,0 +1,87 @@
+import * as Util from '../util/all';
+
+import * as P from './poly';
+import * as PP from './polypack';
+
+// Given three colinear points p, q, r, the function checks if
+// point q lies on line segment 'pr'
+function onSegment(px: number, py: number, qx: number, qy: number, rx: number, ry: number): boolean
+{
+  if (qx <= Math.max(px, rx) && qx >= Math.min(px, rx) &&
+      qy <= Math.max(py, ry) && qy >= Math.min(py, ry))
+     return true;
+
+  return false;
+}
+
+// To find orientation of ordered triplet (p, q, r).
+// The function returns following values
+// 0 --> p, q and r are colinear
+// 1 --> Clockwise
+// 2 --> Counterclockwise
+function orientation(px: number, py: number, qx: number, qy: number, rx: number, ry: number): number
+{
+  // See https://www.geeksforgeeks.org/orientation-3-ordered-points/
+  // for details of below formula.
+  let val: number = (qy - py) * (rx - qx) -
+                    (qx - px) * (ry - qy);
+
+  if (val == 0) return 0;  // colinear
+
+  return (val > 0)? 1: 2; // clock or counterclock wise
+}
+
+// The main function that returns true if line segment 'p1q1'
+// and 'p2q2' intersect.
+function doIntersect(p1x: number, p1y: number, q1x: number, q1y: number, p2x: number, p2y: number, q2x: number, q2y: number): boolean
+{
+    // closing segment is not intersection
+    if (p1x - q2x + p1y - q2y === 0) return false;
+
+    // Find the four orientations needed for general and
+    // special cases
+    let o1 = orientation(p1x, p1y, q1x, q1y, p2x, p2y);
+    let o2 = orientation(p1x, p1y, q1x, q1y, q2x, q2y);
+    let o3 = orientation(p2x, p2y, q2x, q2y, p1x, p1y);
+    let o4 = orientation(p2x, p2y, q2x, q2y, q1x, q1y);
+
+    // General case
+    if (o1 != o2 && o3 != o4)
+      return true;
+
+    // Special Cases
+    // p1, q1 and p2 are colinear and p2 lies on segment p1q1
+    if (o1 == 0 && onSegment(p1x, p1y, p2x, p2y, q1x, q1y)) return true;
+
+    // p1, q1 and q2 are colinear and q2 lies on segment p1q1
+    if (o2 == 0 && onSegment(p1x, p1y, q2x, q2y, q1x, q1y)) return true;
+
+    // p2, q2 and p1 are colinear and p1 lies on segment p2q2
+    if (o3 == 0 && onSegment(p2x, p2y, p1x, p1y, q2x, q2y)) return true;
+
+     // p2, q2 and q1 are colinear and q1 lies on segment p2q2
+    if (o4 == 0 && onSegment(p2x, p2y, q1x, q1y, q2x, q2y)) return true;
+
+    return false; // Doesn't fall in any of the above cases
+}
+
+// no extra storage, but brute-force O(N^2) in number of segments. See selfIntersectFast for better approach.
+export function selfIntersect(poly: any): boolean
+{
+  let pp = P.polyNormalize(poly);
+  if (pp == null) return false;
+  let bIntersect = false;
+  PP.polyPackEachRing(pp, (b: Float64Array, iPoly: number, iRing: number, iOffset: number, nPoints: number) => {
+      if (bIntersect) return;
+      let iEnd = iOffset + ((nPoints-2) * 2);
+      let jEnd = iOffset + ((nPoints-1) * 2);
+      for (let i = iOffset; i < iEnd; i += 2)
+        for (let j = i + 4; j < jEnd; j += 2)
+          if (doIntersect(b[i], b[i+1], b[i+2], b[i+3], b[j], b[j+1], b[j+2], b[j+3]))
+          {
+            bIntersect = true;
+            return;
+          }
+    });
+  return bIntersect;
+}

package/lib/poly/shamos.ts

@@ -0,0 +1,297 @@
+import * as Util from '../util/all';
+
+import * as P from './poly';
+import * as PP from './polypack';
+
+// Adapted from rowanwins/shamos-hoey 
+/*
+MIT License
+
+Copyright (c) 2019 Rowan Winsemius
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+// External libraries
+import TinyQueue from 'tinyqueue'
+import SplayTree from 'splaytree'
+
+class Event
+{
+  x: number;
+  y: number;
+  otherEvent: Event;
+  isLeftEndpoint: boolean | null;
+  segment: Segment;
+
+  constructor(x: number, y: number)
+  {
+    this.x = x
+    this.y = y
+
+    this.otherEvent = null
+    this.isLeftEndpoint = null
+    this.segment = null
+  }
+
+  isOtherEndOfSegment(eventToCheck: Event): boolean
+  {
+    return this === eventToCheck.otherEvent
+  }
+
+  isSamePoint(eventToCheck: Event): boolean
+  {
+    return this.x === eventToCheck.x && this.y === eventToCheck.y
+  }
+
+  isBelow(p: Event): boolean
+  {
+    return this.isLeftEndpoint ?
+        signedArea(this, this.otherEvent, p) > 0 :
+        signedArea(this.otherEvent, p, this) > 0
+  }
+
+  isAbove(p: Event): boolean
+  {
+    return !this.isBelow(p)
+  }
+}
+
+class EventQueue
+{
+  tiny: TinyQueue<Event>;
+
+  constructor()
+  {
+    this.tiny = new TinyQueue<Event>([], checkWhichEventIsLeft)
+  }
+
+  push(event: Event): void { this.tiny.push(event) }
+  pop(): Event { return this.tiny.pop() as Event }
+  get length(): number { return this.tiny.length }
+}
+
+class Segment
+{
+  leftSweepEvent: Event;
+  rightSweepEvent: Event;
+  segmentAbove: Segment;
+  segmentBelow: Segment;
+
+  constructor(event: Event)
+  {
+    this.leftSweepEvent = event
+    this.rightSweepEvent = event.otherEvent
+    this.segmentAbove = null
+    this.segmentBelow = null
+
+    event.segment = this
+    event.otherEvent.segment = this
+  }
+}
+
+class SweepLine
+{
+  tree: SplayTree<Segment>;
+
+  constructor()
+  {
+    this.tree = new SplayTree<Segment>(compareSegments)
+  }
+
+  addSegment(event: Event): Segment
+  {
+     const seg = new Segment(event)
+     const node: any = this.tree.insert(seg)
+     const nextNode: any = this.tree.next(node)
+     const prevNode: any = this.tree.prev(node)
+     if (nextNode !== null)
+     {
+       seg.segmentAbove = nextNode.key
+       seg.segmentAbove.segmentBelow = seg
+     }
+     if (prevNode !== null)
+     {
+       seg.segmentBelow = prevNode.key
+       seg.segmentBelow.segmentAbove = seg
+     }
+     return node.key
+  }
+
+  findSegment(seg: Segment): Segment
+  {
+     const node: any = this.tree.find(seg)
+     if (node === null) return null
+     return node.key
+  }
+
+  removeSegmentFromSweepline(seg: Segment): void
+  {
+    const node: any = this.tree.find(seg)
+    if (node === null) return
+    const nextNode: any = this.tree.next(node)
+    const prevNode: any = this.tree.prev(node)
+
+    if (nextNode !== null)
+    {
+      const nextSeg = nextNode.key
+      nextSeg.segmentBelow = seg.segmentBelow
+    }
+    if (prevNode !== null)
+    {
+      const prevSeg = prevNode.key
+      prevSeg.segmentAbove = seg.segmentAbove
+    }
+    this.tree.remove(seg)
+  }
+
+  testIntersect(seg1: Segment, seg2: Segment): boolean
+  {
+    if (seg1 === null || seg2 === null) return false
+
+    if (seg1.rightSweepEvent.isSamePoint(seg2.leftSweepEvent) ||
+        seg1.rightSweepEvent.isSamePoint(seg2.rightSweepEvent) ||
+        seg1.leftSweepEvent.isSamePoint(seg2.leftSweepEvent) ||
+        seg1.leftSweepEvent.isSamePoint(seg2.rightSweepEvent)) return false
+
+    const x1 = seg1.leftSweepEvent.x
+    const y1 = seg1.leftSweepEvent.y
+    const x2 = seg1.rightSweepEvent.x
+    const y2 = seg1.rightSweepEvent.y
+    const x3 = seg2.leftSweepEvent.x
+    const y3 = seg2.leftSweepEvent.y
+    const x4 = seg2.rightSweepEvent.x
+    const y4 = seg2.rightSweepEvent.y
+
+    const denom = ((y4 - y3) * (x2 - x1)) - ((x4 - x3) * (y2 - y1))
+    const numeA = ((x4 - x3) * (y1 - y3)) - ((y4 - y3) * (x1 - x3))
+    const numeB = ((x2 - x1) * (y1 - y3)) - ((y2 - y1) * (x1 - x3))
+
+    if (denom === 0)
+    {
+      if (numeA === 0 && numeB === 0) return false
+      return false
+    }
+
+    const uA = numeA / denom
+    const uB = numeB / denom
+
+    return (uA >= 0 && uA <= 1 && uB >= 0 && uB <= 1)
+  }
+}
+
+function checkWhichEventIsLeft(e1: Event, e2: Event): number
+{
+  if (e1.x > e2.x) return 1
+  if (e1.x < e2.x) return -1
+
+  if (e1.y !== e2.y) return e1.y > e2.y ? 1 : -1
+  return 1
+}
+
+function compareSegments(seg1: Segment, seg2: Segment): number
+{
+  if (seg1 === seg2) return 0
+
+  if (signedArea(seg1.leftSweepEvent, seg1.rightSweepEvent, seg2.leftSweepEvent) !== 0 ||
+      signedArea(seg1.leftSweepEvent, seg1.rightSweepEvent, seg2.rightSweepEvent) !== 0)
+  {
+    // If the segments share their left endpoints
+    // use the right endpoint to sort
+    if (seg1.leftSweepEvent.isSamePoint(seg2.leftSweepEvent)) return seg1.leftSweepEvent.isBelow(seg2.rightSweepEvent) ? -1 : 1
+
+    // If the segments have different left endpoints
+    // use the left endpoint to sort
+    if (seg1.leftSweepEvent.x === seg2.leftSweepEvent.x) return seg1.leftSweepEvent.y < seg2.leftSweepEvent.y  ? -1 : 1
+
+    // If the line segment associated to e1 been inserted
+    // into S after the line segment associated to e2 ?
+    if (checkWhichEventIsLeft(seg1.leftSweepEvent, seg2.leftSweepEvent) === 1) return seg2.leftSweepEvent.isAbove(seg1.leftSweepEvent) ? -1 : 1
+
+    // The line segment associated to e2 has been inserted
+    // into S after the line segment associated to e1
+    return seg1.leftSweepEvent.isBelow(seg2.leftSweepEvent) ? -1 : 1
+  }
+
+  return checkWhichEventIsLeft(seg1.leftSweepEvent, seg2.leftSweepEvent) === 1 ? 1 : -1
+}
+
+function runCheck(eventQueue: EventQueue): boolean
+{
+  const sweepLine = new SweepLine()
+  let currentSegment = null
+  while (eventQueue.length)
+  {
+    const event = eventQueue.pop()
+
+    if (event.isLeftEndpoint)
+    {
+      currentSegment = sweepLine.addSegment(event)
+      if (sweepLine.testIntersect(currentSegment, currentSegment.segmentAbove)) return true
+      if (sweepLine.testIntersect(currentSegment, currentSegment.segmentBelow)) return true
+    }
+    else
+    {
+      if (!event.segment) continue
+      if (sweepLine.testIntersect(event.segment.segmentAbove, event.segment.segmentBelow)) return true
+      sweepLine.removeSegmentFromSweepline(event.segment)
+    }
+  }
+  return false
+}
+
+function signedArea(p0: any, p1: any, p2: any): number
+{
+  return (p0.x - p2.x) * (p1.y - p2.y) - (p1.x - p2.x) * (p0.y - p2.y)
+}
+
+export function selfIntersectFast(poly: any): boolean
+{
+  let pp = P.polyNormalize(poly);
+  if (pp == null) return false;
+
+  // Fill queue
+  let eventQueue = new EventQueue();
+  PP.polyPackEachRing(pp, (b: Float64Array, iPoly: number, iRing: number, iOffset: number, nPoints: number) => {
+      let iEnd = iOffset + (nPoints - 1) * 2; // iterating over segments so right before last point
+      for (; iOffset < iEnd; iOffset += 2)
+      {
+        const e1 = new Event(b[iOffset], b[iOffset+1]);
+        const e2 = new Event(b[iOffset+2], b[iOffset+3]);
+
+        e1.otherEvent = e2
+        e2.otherEvent = e1
+
+        if (checkWhichEventIsLeft(e1, e2) > 0)
+        {
+          e2.isLeftEndpoint = true
+          e1.isLeftEndpoint = false
+        }
+        else
+        {
+          e1.isLeftEndpoint = true
+          e2.isLeftEndpoint = false
+        }
+        eventQueue.push(e1)
+        eventQueue.push(e2)
+      }
+    });
+
+  return runCheck(eventQueue)
+}