@dra2020/baseclient 1.0.59 → 1.0.62

package/dist/csv/csv.d.ts

@@ -1 +1,18 @@
-export {};
+import * as Util from '../util/all';
+export declare class ParseOne {
+    coder: Util.Coder;
+    fields: string[];
+    buf: Uint8Array;
+    n: number;
+    tok: Uint8Array;
+    toklen: number;
+    infield: boolean;
+    quote: number;
+    nwhite: number;
+    force: boolean;
+    constructor(coder: Util.Coder, line?: string);
+    set(line: string): void;
+    get length(): number;
+    pushtok(): void;
+    parse(): void;
+}

package/dist/poly/poly.d.ts

@@ -48,6 +48,18 @@ export interface PolyDescription {
 export declare function polyDescribe(poly: any): PolyDescription;
 export declare function npoints(poly: any): number;
 export declare function polyTransform(poly: any, transformFn: any): any;
-export declare function featureRewind(poly: any): any;
+export interface RewindOptions {
+    validateHoles?: boolean;
+    validateClose?: boolean;
+    canonical?: boolean;
+}
+interface Winding {
+    iPoly: number;
+    iRing: number;
+    direction: number;
+}
+export declare function polyRingWindings(poly: any): Winding[];
+export declare function featureRewind(f: any, options?: RewindOptions): any;
 export declare function polyRewindRings(pp: any, bLog?: boolean): any;
 export declare function polyBadCoordinates(f: any): boolean;
+export {};

package/lib/csv/csv.ts

@@ -23,7 +23,7 @@ function isWhite(c: number): boolean
   return c === Space || c === Newline || c === Tab || c == CR;
 }
 
-class ParseOne
+export class ParseOne
 {
   coder: Util.Coder;
   fields: string[]; // output
@@ -34,12 +34,15 @@ class ParseOne
   infield: boolean;
   quote: number;
   nwhite: number;
+  force: boolean;
 
   constructor(coder: Util.Coder, line?: string)
   {
     this.coder = coder;
     if (line)
       this.set(line);
+    else
+      this.fields = [];
   }
 
   set(line: string): void
@@ -52,18 +55,18 @@ class ParseOne
     this.infield = false;
     this.nwhite = 0;
     this.quote = 0;
+    this.force = false;
     this.parse();
   }
 
   get length(): number { return this.fields.length }
 
-  pushtok(force: boolean): void
+  pushtok(): void
   {
     // Trim trailing whitespace
-    if (!force)
-      this.toklen -= this.nwhite;
+    this.toklen -= this.nwhite;
 
-    if (this.toklen || force)
+    if (this.toklen || this.force)
     {
       this.fields.push(Util.u82s(this.coder, this.tok, 0, this.toklen));
       this.toklen = 0;
@@ -71,6 +74,7 @@ class ParseOne
     this.infield = false;
     this.nwhite = 0;
     this.quote = 0;
+    this.force = false;
   }
 
   parse(): void
@@ -79,13 +83,20 @@ class ParseOne
     {
       let c: number = this.buf[this.n++];
       if (this.quote && c === this.quote)
-        this.pushtok(true);
+      {
+        this.quote = 0;
+        this.nwhite = 0;
+      }
       else if (c === Comma || c === Pipe)
-        this.pushtok(true);
+      {
+        this.force = true;
+        this.pushtok();
+        this.force = true;
+      }
       else if (this.infield)
       {
         this.tok[this.toklen++] = c;
-        if (isWhite(c))
+        if (!this.quote && isWhite(c))
           this.nwhite++;
         else
           this.nwhite = 0;
@@ -96,13 +107,15 @@ class ParseOne
       {
         this.quote = c;
         this.infield = true;
+        this.force = true;
       }
       else
       {
         this.infield = true;
         this.tok[this.toklen++] = c;
+        this.force = true;
       }
     }
-    this.pushtok(false);
+    this.pushtok();
   }
 }

package/lib/poly/poly.ts

@@ -667,30 +667,156 @@ function closePoly(poly: any): any
   return poly;
 }
 
+function closeFeature(f: any): void
+{
+  let d = Util.depthof(f.geometry.coordinates);
+  if (d === 4) closePoly(f.geometry.coordinates);
+  if (d === 5) f.geometry.coordinates.forEach(closePoly);
+}
+
+export interface RewindOptions
+{
+  validateHoles?: boolean,
+  validateClose?: boolean,
+  canonical?: boolean,
+}
+
+function canonicalPoint(f: any, options: RewindOptions): any
+{
+  if (options.canonical)
+    if (f && f.geometry && f.geometry.type === 'Point' && f.geometry.coordinates)
+      while (Array.isArray(f.geometry.coordinates[0]))
+        f.geometry.coordinates = f.geometry.coordinates[0];
+  return f;
+}
+
+//
+// polyRingWindings: Return depth-first array of winding of each ring in the feature.
+//    value < 0: CW
+//    value > 0: CCW
+//
+
+interface Winding { iPoly: number, iRing: number, direction: number };
+
+function misWound(w: Winding): boolean
+{
+  return (((w.iRing == 0) && (w.direction > 0)) || ((w.iRing > 0) && (w.direction < 0)));
+}
+
+export function polyRingWindings(poly: any): Winding[]
+{
+  let windings: Winding[] = [];
+
+  let pp = polyNormalize(poly);
+  if (pp == null || pp.buffer == null) return windings;
+
+  PP.polyPackEachRing(pp, (b: Float64Array, iPoly: number, iRing: number, iOffset: number, nPoints: number) =>
+  {
+    const iStart = iOffset;
+    const iEnd = iStart + (nPoints * 2) - 2;
+
+    // Determine the winding order of the ring
+    let direction = 0;
+
+    // Start at the second point
+    iOffset += 2;
+    for (; iOffset <= iEnd; iOffset += 2)
+    {
+      // The previous point
+      let jOffset = iOffset - 2;
+
+      // Sum over the edges
+      direction += twoTimesArea(b[iOffset], b[jOffset], b[iOffset+1], b[jOffset+1]);
+    }
+    
+    // Implicitly close the ring, if necessary
+    if (nPoints > 2 && (b[iStart] != b[iEnd] || b[iStart + 1] != b[iEnd + 1]))
+      direction += twoTimesArea(b[iStart], b[iEnd], b[iStart + 1], b[iEnd + 1]);
+
+    windings.push({ iPoly: iPoly, iRing: iRing, direction: direction });
+  });
+  return windings;
+}
+
+
 // This mutates the passed in feature to ensure it is correctly wound
 // For convenience, passed back the value provided.
-export function featureRewind(poly: any): any
+//
+export function featureRewind(f: any, options?: RewindOptions): any
 {
-  let pp = polyNormalize(poly);
-  if (pp == null) return null;
-  polyRewindRings(pp);
-  if (poly.type === 'Feature')
+  options = Util.shallowAssignImmutable({ validateHoles: true, validateClose: true, canonical: true }, options);
+
+  if (!f) return null;
+
+  // Has to be an unpacked feature
+  if (f.type !== 'Feature') throw 'featureRewind: must be a valid GeoJSON feature';
+  if (!f.geometry || f.geometry.packed) throw 'featureRewind: only valid on unpacked features';
+
+  // Non polygons are simpler
+  if (f.geometry.type !== 'Polygon' && f.geometry.type !== 'MultiPolygon') return canonicalPoint(f, options);
+
+  // Make sure polygon is closed (first === last)
+  if (options.validateClose) closeFeature(f);
+
+  // Check if multi-polygon is really polygon with holes
+  // Only applies to multi-polygons with no holes
+  let d = Util.depthof(f.geometry.coordinates);
+  let windings = polyRingWindings(f);
+  if (options.validateHoles && d === 5 && windings.length)
   {
-    if (poly.geometry.packed !== pp)
+    // If there are explicit holes, don't look for implicit ones
+    let nHoles = 0; windings.forEach(w => { if (w.iRing) nHoles++ });
+    if (nHoles == 0 && !misWound(windings[0]))
+    {
+      // Looking for pattern: of (G (B*))*
+      // To convert to ((GH*))*
+      let iWinding = 0;
+      let polys = f.geometry.coordinates;
+      let iPoly: number;
+      for (; iWinding < windings.length; iWinding++)
+      {
+        let good = !misWound(windings[iWinding]);
+        if (!good && iWinding == 0) // First is miswound - no good
+          break;
+        if (good)
+          iPoly = iWinding;
+        else
+        {
+          polys[iPoly].push(polys[iWinding][0]);
+          polys[iWinding] = null;
+        }
+      }
+      f.geometry.coordinates = polys.filter((p: any) => p != null);
+    }
+
+    // Degenerate multi-polygon
+    if (f.geometry.coordinates.length == 1)
     {
-      poly.geometry.coordinates = PP.polyUnpack(pp);
-      // Also make sure first === last coordinate
-      let d = Util.depthof(poly.geometry.coordinates);
-      if (d === 4) closePoly(poly.geometry.coordinates);
-      else if (d === 5) poly.geometry.coordinates.forEach(closePoly);
-      poly.geometry.type = d === 4 ? 'Polygon' : 'MultiPolygon';
+      f.geometry.type = 'Polygon';
+      f.geometry.coordinates = f.geometry.coordinates[0];
     }
-    return poly;
   }
-  else if (poly === pp)
-    return pp;
-  else
-    return PP.polyUnpack(pp);
+
+  // OK, now go through each ring
+  let polys = f.geometry.coordinates;
+  windings = polyRingWindings(f);
+  windings.forEach((w: Winding) => {
+      let good = !misWound(w);
+      if (!good)
+      {
+        let ring = polys[w.iPoly][w.iRing];
+        let iFront = 0;
+        let iBack = ring.length-1;
+        for (; iFront < iBack; iFront++, iBack--)
+        {
+          let tmp = ring[iFront];
+          ring[iFront] = ring[iBack];
+          ring[iBack] = tmp;
+        }
+      }
+    });
+
+  return f;
 }
 
 //

package/lib/poly/topo.ts

@@ -84,7 +84,7 @@ function correctGeometry(f: any): any
   }
   else
     // TopoJSON does not guarantee proper winding order which messes up later processing. Fix it.
-    P.featureRewind(f);
+    P.featureRewind(f, { validateHoles: false } );
 
   return f;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dra2020/baseclient",
-  "version": "1.0.59",
+  "version": "1.0.62",
   "description": "Utility functions for Javascript projects.",
   "main": "dist/baseclient.js",
   "types": "./dist/all/all.d.ts",