mapshaper 0.7.30 → 0.7.32

package/mapshaper.js

@@ -32938,6 +32938,10 @@ ${svg}
         describe: 'shrinkage-correction (default 1; 0 = none, >1 exaggerates bends)',
         type: 'number'
       })
+      .option('max-bend-angle', {
+        describe: 'max bend between output segments in degrees (default is 8)',
+        type: 'number'
+      })
       .option('planar', {
         // describe: 'smooth decimal degree coords in 2D space (default is spherical)',
         type: 'flag'
@@ -57238,7 +57242,16 @@ ${svg}
   //     distance D) segments the line into runs that each fit within the detail
   //     scale and bounds every candidate chord to <= D, so cuts stay local.
   //
-  //  2. COMMIT selectively. For each run of removed vertices between two survivors,
+  //  2. MERGE survivors that hide a slicing chord. A spike with long bare flanks
+  //     parks its base vertices as survivors (each flank chord alone exceeds D), so
+  //     the short chord that closes the excursion sits between non-adjacent
+  //     survivors. Where a near-degenerate closing chord (a needle returning close
+  //     to its base: chord <= MERGE_CHORD_FRACTION * D, tortuosity >= threshold)
+  //     exists within an arc-length window, widen the run so the next phase can
+  //     slice it. Restricting to short closing chords keeps the merge from sweeping
+  //     a wide excursion across neighbouring geometry and introducing a crossing.
+  //
+  //  3. COMMIT selectively. For each run of removed vertices between two survivors,
   //     compare the original sub-path length to the chord across it (tortuosity).
   //     Collapse the run to its chord only when it is convoluted (tortuosity >=
   //     threshold) -- a jetty, fjord or crinkle. Otherwise restore the run's
@@ -57256,6 +57269,16 @@ ${svg}
   // topology nodes stay put and the operation is topology-safe like -simplify.
   var DEFAULT_WEIGHTING = 0.7;
   var DEFAULT_TORTUOSITY = 2;
+  // How far (in detail-distances of arc length) the survivor-merge pass looks ahead
+  // for a chord that closes a convoluted excursion. Bounds the pass to O(n) and
+  // caps how long a thin spike it can slice in one merge.
+  var MERGE_WINDOW_FACTOR = 12;
+  // The survivor-merge pass only fires when the closing chord is this fraction of D
+  // or shorter: a near-degenerate needle that returns close to its base can be
+  // sliced safely, but collapsing a wider excursion (chord approaching D) sweeps a
+  // long span across neighbouring geometry and can introduce a crossing. cutRun,
+  // which spans only adjacent survivors, is not constrained this way.
+  var MERGE_CHORD_FRACTION = 0.5;
 
   function collapseArcDetail(xx, yy, opts) {
     var n = xx.length;
@@ -57378,6 +57401,47 @@ ${svg}
       }
     }
 
+    // Survivor-merge pass. A thin spike with long bare flanks (e.g. a fjord wall or
+    // a dredged channel) forces its base vertices to be parked as survivors -- each
+    // flank chord on its own exceeds D -- so the short chord that actually closes
+    // the excursion is hidden between *non-adjacent* survivors and the per-run
+    // cutRun above never sees it. Walk the survivor chain and, where a later
+    // survivor closes a convoluted excursion with a short chord (<=
+    // MERGE_CHORD_FRACTION * D, tortuosity >= T) within an arc-length window,
+    // splice out the spanned survivors so the run boundary widens and cutRun slices
+    // the spike off. Restricting to short closing chords keeps the merge from
+    // sweeping a wide excursion across neighbouring geometry. This reuses cumLen and the
+    // peel's linked list; it does not re-run the Visvalingam peel. Only non-adjacent
+    // convoluted survivors are merged, so gentle runs (and all existing behaviour)
+    // are untouched.
+    var window = MERGE_WINDOW_FACTOR * D;
+    var mergeChordSq = Dsq * MERGE_CHORD_FRACTION * MERGE_CHORD_FRACTION;
+    var s = 0;
+    while (s !== n - 1) {
+      var mergeJ = -1;
+      var mergeTort = T;
+      var u = next[s];
+      while (cumLen[u] - cumLen[s] <= window) {
+        if (chordSq(s, u) <= mergeChordSq) {
+          var ud = dist(s, u);
+          var utort = ud > 0 ? (cumLen[u] - cumLen[s]) / ud : Infinity;
+          if (utort > mergeTort) {
+            mergeTort = utort;
+            mergeJ = u;
+          }
+        }
+        if (u === n - 1) break;
+        u = next[u];
+      }
+      if (mergeJ > next[s]) {
+        next[s] = mergeJ;
+        prev[mergeJ] = s;
+        s = mergeJ;
+      } else {
+        s = next[s];
+      }
+    }
+
     outX.push(xx[0]);
     outY.push(yy[0]);
     var a = 0;
@@ -62527,20 +62591,25 @@ ${svg}
   // chord * accumulatedTurn / 8 estimates the bow of a circular arc, and we also
   // cut when it exceeds a fraction of the tolerance. Both tests are O(1) per dense
   // vertex, so the pass stays O(n).
-  var DENSE_STEP_FACTOR = 0.033;      // dense sampling step = tolerance * this. Must
-                                      // resolve the sharpest smoothed feature (radius
-                                      // ~ the kernel scale) finely enough that the
-                                      // angle filter can reach BEND_ANGLE joins: one
-                                      // dense segment turns ~ this/0.4 radians there,
-                                      // kept well under BEND_ANGLE so the discrete
-                                      // accumulation barely overshoots the threshold.
-  var BEND_ANGLE = 8 * Math.PI / 180; // keep a vertex after this much accumulated turn
+  var DENSE_STEP_FACTOR = 0.033;      // dense sampling step = tolerance * this at the
+                                      // default bend angle. Must resolve the sharpest
+                                      // smoothed feature (radius ~ the kernel scale)
+                                      // finely enough that the angle filter can reach
+                                      // the bend-angle joins: one dense segment turns
+                                      // ~ this/0.4 radians there, kept well under the
+                                      // bend angle so the discrete accumulation barely
+                                      // overshoots the threshold. For a smaller-than-
+                                      // default bend angle the step is refined in
+                                      // proportion so the threshold stays reachable.
+  var DEFAULT_BEND_ANGLE = 8 * Math.PI / 180; // keep a vertex after this much accumulated
+                                      // turn (max turn between consecutive output
+                                      // segments); user-overridable via max-bend-angle
   var DEVIATION_FACTOR = 0.1;         // sagitta guard: also cut a gentle bend that bows
                                       // more than tolerance * this from its chord
 
   // Smooth a single arc's coordinates.
   // @xx, @yy: coordinate arrays (may be typed-array subarrays) for one arc.
-  // @opts: {tolerance, method, spherical, closed, keepCorners}
+  // @opts: {tolerance, method, spherical, closed, keepCorners, gain, maxBendAngle}
   // Returns {xx: [], yy: []} with the smoothed coordinates. Endpoints of open
   // arcs are preserved exactly (so shared topology nodes stay put); closed arcs
   // are smoothed cyclically and returned closed (first point repeated at the end).
@@ -62555,6 +62624,16 @@ ${svg}
     return g >= 0 ? g : 0;
   }
 
+  // Resolve the output bend-angle threshold from the user option (in degrees) to
+  // radians. It caps the turn between consecutive output segments: a larger angle
+  // keeps fewer vertices (coarser joins), a smaller one keeps more (smoother joins).
+  // Non-positive or missing values fall back to the default.
+  function resolveBendAngle(opts) {
+    var deg = opts.maxBendAngle;
+    if (deg === undefined || deg === null || !(deg > 0)) return DEFAULT_BEND_ANGLE;
+    return deg * Math.PI / 180;
+  }
+
   function smoothArcCoords(xx, yy, opts) {
     var n = xx.length;
     var origX = toArray(xx);
@@ -62567,12 +62646,18 @@ ${svg}
     var closed = !!opts.closed;
     var spherical = !!opts.spherical;
     var keepCorners = !!opts.keepCorners;
+    var bendAngle = resolveBendAngle(opts);
     var ctx = {
       tol: tol,
       method: method,
       spherical: spherical,
       keepCorners: keepCorners,
       gain: resolveGain(opts),
+      bendAngle: bendAngle,
+      // Refine the dense step for a smaller-than-default bend angle so one dense
+      // segment still turns well under the threshold; never coarsen it beyond the
+      // default (the angle filter alone thins the output for larger angles).
+      denseStep: tol * DENSE_STEP_FACTOR * Math.min(1, bendAngle / DEFAULT_BEND_ANGLE),
       radius: tol * WINDOW_RADIUS_FACTOR,
       scale: (method == 'gaussian' ? GAUSSIAN_SIGMA_FACTOR : PAEK_SCALE_FACTOR) * tol
     };
@@ -62804,7 +62889,7 @@ ${svg}
   // "Output resampling" note above). Step 1 evaluates the smoother at a uniform
   // dense step; step 2 makes one forward pass keeping the endpoints plus every
   // interior vertex where the accumulated turn since the last kept vertex reaches
-  // BEND_ANGLE, or where the sagitta guard trips. @inputCount bounds the dense
+  // the bend-angle threshold, or where the sagitta guard trips. @inputCount bounds the dense
   // sampling (and thus the output). Returns one array per channel, ordered by
   // increasing arc length, including both endpoints.
   function sampleSmoothedCurve(src, a, b, closed, ctx, inputCount) {
@@ -62813,7 +62898,7 @@ ${svg}
     var maxPoints = Math.max(inputCount, MIN_CLOSED_SEGMENTS) * MAX_OUTPUT_FACTOR;
 
     // 1. dense uniform sampling of the smoothed curve
-    var nDense = Math.ceil(span / (ctx.tol * DENSE_STEP_FACTOR)) + 1;
+    var nDense = Math.ceil(span / ctx.denseStep) + 1;
     if (nDense < MIN_CLOSED_SEGMENTS + 1) nDense = MIN_CLOSED_SEGMENTS + 1;
     if (nDense > maxPoints) nDense = maxPoints;
     if (nDense < 2) nDense = 2;
@@ -62823,7 +62908,7 @@ ${svg}
     }
 
     // 2. one-pass bend-angle filter
-    var theta = BEND_ANGLE;
+    var theta = ctx.bendAngle;
     var epsDev = ctx.tol * DEVIATION_FACTOR;
     var out = [];
     for (var c = 0; c < K; c++) out.push([]);
@@ -63120,6 +63205,10 @@ ${svg}
     if (opts.gain !== undefined && opts.gain !== null && !(opts.gain >= 0)) {
       stop$1('Expected gain to be a number >= 0');
     }
+    if (opts.max_bend_angle !== undefined && opts.max_bend_angle !== null &&
+        !(opts.max_bend_angle > 0)) {
+      stop$1('Expected max-bend-angle to be a number > 0 (degrees)');
+    }
     var implicitlySmoothedNames = getImplicitlyTargetedLayerNames(dataset, targetLayers, layerHasPaths);
 
     // Smoothing rewrites coordinates, so lock in any pending (non-destructive)
@@ -63150,7 +63239,8 @@ ${svg}
       method: method,
       spherical: spherical,
       keepCorners: !!opts.keep_corners,
-      gain: opts.gain
+      gain: opts.gain,
+      maxBendAngle: opts.max_bend_angle
     });
 
     if (implicitlySmoothedNames.length > 0) {
@@ -63177,6 +63267,7 @@ ${svg}
         spherical: opts.spherical,
         keepCorners: opts.keepCorners,
         gain: opts.gain,
+        maxBendAngle: opts.maxBendAngle,
         closed: arcs.arcIsClosed(arcId)
       });
       nn.push(res.xx.length);
@@ -64993,7 +65084,7 @@ ${svg}
     return name == 'rectangle' || name == 'rectangles' || name == 'filter' && opts.cleanup;
   }
 
-  var version = "0.7.30";
+  var version = "0.7.32";
 
   // Parse command line args into commands and run them
   // Function takes an optional Node-style callback. A Promise is returned if no callback is given.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mapshaper",
-  "version": "0.7.30",
+  "version": "0.7.32",
   "description": "A tool for editing geospatial data for mapping and GIS.",
   "keywords": [
     "shapefile",

package/www/mapshaper.js

@@ -32938,6 +32938,10 @@ ${svg}
         describe: 'shrinkage-correction (default 1; 0 = none, >1 exaggerates bends)',
         type: 'number'
       })
+      .option('max-bend-angle', {
+        describe: 'max bend between output segments in degrees (default is 8)',
+        type: 'number'
+      })
       .option('planar', {
         // describe: 'smooth decimal degree coords in 2D space (default is spherical)',
         type: 'flag'
@@ -57238,7 +57242,16 @@ ${svg}
   //     distance D) segments the line into runs that each fit within the detail
   //     scale and bounds every candidate chord to <= D, so cuts stay local.
   //
-  //  2. COMMIT selectively. For each run of removed vertices between two survivors,
+  //  2. MERGE survivors that hide a slicing chord. A spike with long bare flanks
+  //     parks its base vertices as survivors (each flank chord alone exceeds D), so
+  //     the short chord that closes the excursion sits between non-adjacent
+  //     survivors. Where a near-degenerate closing chord (a needle returning close
+  //     to its base: chord <= MERGE_CHORD_FRACTION * D, tortuosity >= threshold)
+  //     exists within an arc-length window, widen the run so the next phase can
+  //     slice it. Restricting to short closing chords keeps the merge from sweeping
+  //     a wide excursion across neighbouring geometry and introducing a crossing.
+  //
+  //  3. COMMIT selectively. For each run of removed vertices between two survivors,
   //     compare the original sub-path length to the chord across it (tortuosity).
   //     Collapse the run to its chord only when it is convoluted (tortuosity >=
   //     threshold) -- a jetty, fjord or crinkle. Otherwise restore the run's
@@ -57256,6 +57269,16 @@ ${svg}
   // topology nodes stay put and the operation is topology-safe like -simplify.
   var DEFAULT_WEIGHTING = 0.7;
   var DEFAULT_TORTUOSITY = 2;
+  // How far (in detail-distances of arc length) the survivor-merge pass looks ahead
+  // for a chord that closes a convoluted excursion. Bounds the pass to O(n) and
+  // caps how long a thin spike it can slice in one merge.
+  var MERGE_WINDOW_FACTOR = 12;
+  // The survivor-merge pass only fires when the closing chord is this fraction of D
+  // or shorter: a near-degenerate needle that returns close to its base can be
+  // sliced safely, but collapsing a wider excursion (chord approaching D) sweeps a
+  // long span across neighbouring geometry and can introduce a crossing. cutRun,
+  // which spans only adjacent survivors, is not constrained this way.
+  var MERGE_CHORD_FRACTION = 0.5;
 
   function collapseArcDetail(xx, yy, opts) {
     var n = xx.length;
@@ -57378,6 +57401,47 @@ ${svg}
       }
     }
 
+    // Survivor-merge pass. A thin spike with long bare flanks (e.g. a fjord wall or
+    // a dredged channel) forces its base vertices to be parked as survivors -- each
+    // flank chord on its own exceeds D -- so the short chord that actually closes
+    // the excursion is hidden between *non-adjacent* survivors and the per-run
+    // cutRun above never sees it. Walk the survivor chain and, where a later
+    // survivor closes a convoluted excursion with a short chord (<=
+    // MERGE_CHORD_FRACTION * D, tortuosity >= T) within an arc-length window,
+    // splice out the spanned survivors so the run boundary widens and cutRun slices
+    // the spike off. Restricting to short closing chords keeps the merge from
+    // sweeping a wide excursion across neighbouring geometry. This reuses cumLen and the
+    // peel's linked list; it does not re-run the Visvalingam peel. Only non-adjacent
+    // convoluted survivors are merged, so gentle runs (and all existing behaviour)
+    // are untouched.
+    var window = MERGE_WINDOW_FACTOR * D;
+    var mergeChordSq = Dsq * MERGE_CHORD_FRACTION * MERGE_CHORD_FRACTION;
+    var s = 0;
+    while (s !== n - 1) {
+      var mergeJ = -1;
+      var mergeTort = T;
+      var u = next[s];
+      while (cumLen[u] - cumLen[s] <= window) {
+        if (chordSq(s, u) <= mergeChordSq) {
+          var ud = dist(s, u);
+          var utort = ud > 0 ? (cumLen[u] - cumLen[s]) / ud : Infinity;
+          if (utort > mergeTort) {
+            mergeTort = utort;
+            mergeJ = u;
+          }
+        }
+        if (u === n - 1) break;
+        u = next[u];
+      }
+      if (mergeJ > next[s]) {
+        next[s] = mergeJ;
+        prev[mergeJ] = s;
+        s = mergeJ;
+      } else {
+        s = next[s];
+      }
+    }
+
     outX.push(xx[0]);
     outY.push(yy[0]);
     var a = 0;
@@ -62527,20 +62591,25 @@ ${svg}
   // chord * accumulatedTurn / 8 estimates the bow of a circular arc, and we also
   // cut when it exceeds a fraction of the tolerance. Both tests are O(1) per dense
   // vertex, so the pass stays O(n).
-  var DENSE_STEP_FACTOR = 0.033;      // dense sampling step = tolerance * this. Must
-                                      // resolve the sharpest smoothed feature (radius
-                                      // ~ the kernel scale) finely enough that the
-                                      // angle filter can reach BEND_ANGLE joins: one
-                                      // dense segment turns ~ this/0.4 radians there,
-                                      // kept well under BEND_ANGLE so the discrete
-                                      // accumulation barely overshoots the threshold.
-  var BEND_ANGLE = 8 * Math.PI / 180; // keep a vertex after this much accumulated turn
+  var DENSE_STEP_FACTOR = 0.033;      // dense sampling step = tolerance * this at the
+                                      // default bend angle. Must resolve the sharpest
+                                      // smoothed feature (radius ~ the kernel scale)
+                                      // finely enough that the angle filter can reach
+                                      // the bend-angle joins: one dense segment turns
+                                      // ~ this/0.4 radians there, kept well under the
+                                      // bend angle so the discrete accumulation barely
+                                      // overshoots the threshold. For a smaller-than-
+                                      // default bend angle the step is refined in
+                                      // proportion so the threshold stays reachable.
+  var DEFAULT_BEND_ANGLE = 8 * Math.PI / 180; // keep a vertex after this much accumulated
+                                      // turn (max turn between consecutive output
+                                      // segments); user-overridable via max-bend-angle
   var DEVIATION_FACTOR = 0.1;         // sagitta guard: also cut a gentle bend that bows
                                       // more than tolerance * this from its chord
 
   // Smooth a single arc's coordinates.
   // @xx, @yy: coordinate arrays (may be typed-array subarrays) for one arc.
-  // @opts: {tolerance, method, spherical, closed, keepCorners}
+  // @opts: {tolerance, method, spherical, closed, keepCorners, gain, maxBendAngle}
   // Returns {xx: [], yy: []} with the smoothed coordinates. Endpoints of open
   // arcs are preserved exactly (so shared topology nodes stay put); closed arcs
   // are smoothed cyclically and returned closed (first point repeated at the end).
@@ -62555,6 +62624,16 @@ ${svg}
     return g >= 0 ? g : 0;
   }
 
+  // Resolve the output bend-angle threshold from the user option (in degrees) to
+  // radians. It caps the turn between consecutive output segments: a larger angle
+  // keeps fewer vertices (coarser joins), a smaller one keeps more (smoother joins).
+  // Non-positive or missing values fall back to the default.
+  function resolveBendAngle(opts) {
+    var deg = opts.maxBendAngle;
+    if (deg === undefined || deg === null || !(deg > 0)) return DEFAULT_BEND_ANGLE;
+    return deg * Math.PI / 180;
+  }
+
   function smoothArcCoords(xx, yy, opts) {
     var n = xx.length;
     var origX = toArray(xx);
@@ -62567,12 +62646,18 @@ ${svg}
     var closed = !!opts.closed;
     var spherical = !!opts.spherical;
     var keepCorners = !!opts.keepCorners;
+    var bendAngle = resolveBendAngle(opts);
     var ctx = {
       tol: tol,
       method: method,
       spherical: spherical,
       keepCorners: keepCorners,
       gain: resolveGain(opts),
+      bendAngle: bendAngle,
+      // Refine the dense step for a smaller-than-default bend angle so one dense
+      // segment still turns well under the threshold; never coarsen it beyond the
+      // default (the angle filter alone thins the output for larger angles).
+      denseStep: tol * DENSE_STEP_FACTOR * Math.min(1, bendAngle / DEFAULT_BEND_ANGLE),
       radius: tol * WINDOW_RADIUS_FACTOR,
       scale: (method == 'gaussian' ? GAUSSIAN_SIGMA_FACTOR : PAEK_SCALE_FACTOR) * tol
     };
@@ -62804,7 +62889,7 @@ ${svg}
   // "Output resampling" note above). Step 1 evaluates the smoother at a uniform
   // dense step; step 2 makes one forward pass keeping the endpoints plus every
   // interior vertex where the accumulated turn since the last kept vertex reaches
-  // BEND_ANGLE, or where the sagitta guard trips. @inputCount bounds the dense
+  // the bend-angle threshold, or where the sagitta guard trips. @inputCount bounds the dense
   // sampling (and thus the output). Returns one array per channel, ordered by
   // increasing arc length, including both endpoints.
   function sampleSmoothedCurve(src, a, b, closed, ctx, inputCount) {
@@ -62813,7 +62898,7 @@ ${svg}
     var maxPoints = Math.max(inputCount, MIN_CLOSED_SEGMENTS) * MAX_OUTPUT_FACTOR;
 
     // 1. dense uniform sampling of the smoothed curve
-    var nDense = Math.ceil(span / (ctx.tol * DENSE_STEP_FACTOR)) + 1;
+    var nDense = Math.ceil(span / ctx.denseStep) + 1;
     if (nDense < MIN_CLOSED_SEGMENTS + 1) nDense = MIN_CLOSED_SEGMENTS + 1;
     if (nDense > maxPoints) nDense = maxPoints;
     if (nDense < 2) nDense = 2;
@@ -62823,7 +62908,7 @@ ${svg}
     }
 
     // 2. one-pass bend-angle filter
-    var theta = BEND_ANGLE;
+    var theta = ctx.bendAngle;
     var epsDev = ctx.tol * DEVIATION_FACTOR;
     var out = [];
     for (var c = 0; c < K; c++) out.push([]);
@@ -63120,6 +63205,10 @@ ${svg}
     if (opts.gain !== undefined && opts.gain !== null && !(opts.gain >= 0)) {
       stop$1('Expected gain to be a number >= 0');
     }
+    if (opts.max_bend_angle !== undefined && opts.max_bend_angle !== null &&
+        !(opts.max_bend_angle > 0)) {
+      stop$1('Expected max-bend-angle to be a number > 0 (degrees)');
+    }
     var implicitlySmoothedNames = getImplicitlyTargetedLayerNames(dataset, targetLayers, layerHasPaths);
 
     // Smoothing rewrites coordinates, so lock in any pending (non-destructive)
@@ -63150,7 +63239,8 @@ ${svg}
       method: method,
       spherical: spherical,
       keepCorners: !!opts.keep_corners,
-      gain: opts.gain
+      gain: opts.gain,
+      maxBendAngle: opts.max_bend_angle
     });
 
     if (implicitlySmoothedNames.length > 0) {
@@ -63177,6 +63267,7 @@ ${svg}
         spherical: opts.spherical,
         keepCorners: opts.keepCorners,
         gain: opts.gain,
+        maxBendAngle: opts.maxBendAngle,
         closed: arcs.arcIsClosed(arcId)
       });
       nn.push(res.xx.length);
@@ -64993,7 +65084,7 @@ ${svg}
     return name == 'rectangle' || name == 'rectangles' || name == 'filter' && opts.cleanup;
   }
 
-  var version = "0.7.30";
+  var version = "0.7.32";
 
   // Parse command line args into commands and run them
   // Function takes an optional Node-style callback. A Promise is returned if no callback is given.