@dra2020/baseclient 1.0.60 → 1.0.63

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/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

@@ -65,28 +65,7 @@ function ringsCancel(outerPoly: any, innerRing: any): boolean
 
 function correctGeometry(f: any): any
 {
-  if (f && f.geometry && f.geometry.type === 'MultiPolygon' && f.geometry.coordinates)
-  {
-    let multiPoly = f.geometry.coordinates;
-
-    // Convert degenerate MultiPolygon to Polygon
-    if (multiPoly.length == 1)
-    {
-      f.geometry.type = 'Polygon';
-      f.geometry.coordinates = multiPoly[0];
-    }
-  }
-
-  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];
-  }
-  else
-    // TopoJSON does not guarantee proper winding order which messes up later processing. Fix it.
-    P.featureRewind(f);
-
-  return f;
+  return P.featureRewind(f, { validateHoles: false } );
 }
 
 export function topoContiguity(topo: Topo): any

package/package.json

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