mapshaper 0.7.63 → 0.7.65

package/mapshaper.js

@@ -27981,6 +27981,12 @@
   // invariant under translation, rotation and scaling (Hobby 1986), which is
   // what lets the tool fit in display coordinates while storing knots in map
   // coordinates.
+  //
+  // Left alone, the method bulges: a hard turn followed by a much shorter
+  // segment throws the long segment into a wide arc, several times the length of
+  // the short one. Two limits below hold that in, MAX_HANDLE and
+  // MAX_CHORD_RATIO. Both are inert on a path whose chords are of comparable
+  // length, so an ordinary label path is fitted exactly as Hobby describes.
 
   // Curl controls how the curve behaves at the two ends of a run. At 0 it
   // approaches a straight line there; at 1 (Metafont's default) it approaches a
@@ -28068,6 +28074,24 @@
       VEL_B = 1 / 16,
       VEL_C = (3 - Math.sqrt(5)) / 2;
 
+  // Longest a control point may sit from its knot, as a fraction of the chord
+  // length that handleLimit() works out for it. See "Bulge" in the design doc: a
+  // hard turn followed by a short segment otherwise throws the long segment into
+  // a wide arc, which during editing is most of the time, because a short
+  // segment is what a half-dragged knot leaves behind.
+  //
+  // The value is a floor, not a preference. Four points on a circle want 0.3905,
+  // which is the roundest any sensible path asks for, so a limit just above it
+  // never touches a curve that was not already misbehaving.
+  var MAX_HANDLE = 0.4;
+
+  // How much longer one chord may be than its neighbour *for the purposes of the
+  // solve*. Hobby equalizes mock curvature across each knot, and a short chord
+  // carries a lot of curvature, so without this a short segment dictates a wide
+  // arc to a long one. Capping the ratio limits how far that reaches without
+  // moving any knot or touching the curve where the chords are even.
+  var MAX_CHORD_RATIO = 1.5;
+
   // Fits a run of knots, returning a cubic per interval.
   function fitRun(pts) {
     var n = pts.length - 1, // segment count
@@ -28084,16 +28108,54 @@
     psi.push(0);
     for (i = 1; i < n; i++) psi.push(wrapAngle(om[i] - om[i - 1]));
 
-    theta = solveDepartureAngles(dd, psi, n);
+    theta = solveDepartureAngles(evenOutChords(dd, n), psi, n);
     phi = getArrivalAngles(theta, psi, n);
 
     for (i = 0; i < n; i++) {
       segments.push(buildSegment(pts[i], pts[i + 1], dd[i], om[i],
-        theta[i], phi[i + 1]));
+        theta[i], phi[i + 1],
+        handleLimit(dd[i], i > 0 ? dd[i - 1] : Infinity),
+        handleLimit(dd[i], i < n - 1 ? dd[i + 1] : Infinity)));
     }
     return segments;
   }
 
+  // Longest a handle may be at one end of a segment whose own chord is @own and
+  // whose neighbour across that knot is @neighbor. (At the first and last knot
+  // of a run there is no neighbour, and the segment's own chord is the measure.)
+  //
+  // The scale is the geometric mean of the two, rather than the shorter of them.
+  // Measuring against the shorter alone holds the bulge down just as well, but
+  // it makes a long segment meeting a short one spend nearly all of its shape at
+  // its far end: on a 490-unit arm meeting a 50-unit leg the two handles came
+  // out 9.8:1, so the arm ran almost straight and then hooked hard into the
+  // knot, and the curvature either side of that knot differed by a factor of 14.
+  // The geometric mean gives the long segment a handle in proportion to how
+  // lopsided the pair actually is, which brings the same case to 3.1:1 and the
+  // curvature to within a factor of 1.4 -- about what Hobby's mock curvature
+  // leaves on an ordinary path anyway -- for two points of extra bulge.
+  function handleLimit(own, neighbor) {
+    return MAX_HANDLE * Math.sqrt(own * Math.min(own, neighbor));
+  }
+
+  // The chord lengths the solve sees, with the ratio between neighbours held to
+  // MAX_CHORD_RATIO. Each length becomes the smallest that any chord permits it
+  // to be, allowing for a factor of MAX_CHORD_RATIO per step -- a forward pass
+  // and a backward pass compute that exactly, so this needs no iteration.
+  //
+  // Only the tangent directions are affected. The curve is still built on the
+  // true chord lengths.
+  function evenOutChords(dd, n) {
+    var out = dd.concat(), i;
+    for (i = 1; i < n; i++) {
+      if (out[i] > out[i - 1] * MAX_CHORD_RATIO) out[i] = out[i - 1] * MAX_CHORD_RATIO;
+    }
+    for (i = n - 2; i >= 0; i--) {
+      if (out[i] > out[i + 1] * MAX_CHORD_RATIO) out[i] = out[i + 1] * MAX_CHORD_RATIO;
+    }
+    return out;
+  }
+
   // The tridiagonal system of Hobby's mock-curvature conditions, in the
   // departure angle at each knot measured from the chord leaving it. Written for
   // unit tension throughout; the general form carries a tension per knot, which
@@ -28137,21 +28199,30 @@
 
   // Turns a pair of angles into a cubic, by way of Hobby's velocity functions --
   // how far along each tangent the control point sits, as a multiple of a third
-  // of the chord.
-  function buildSegment(p0, p1, d, om, theta, phi) {
+  // of the chord -- with each distance held to the caller's limit.
+  //
+  // Shortening a handle leaves its direction alone, so the tangent the two
+  // segments share at a knot is untouched and the curve stays smooth through it.
+  // What it gives up is Hobby's mock-curvature match across that knot, and only
+  // at a knot lopsided enough for the limit to bite.
+  function buildSegment(p0, p1, d, om, theta, phi, maxOut, maxIn) {
     var alpha = VEL_A * (Math.sin(theta) - VEL_B * Math.sin(phi)) *
           (Math.sin(phi) - VEL_B * Math.sin(theta)) *
           (Math.cos(theta) - Math.cos(phi)),
         rho = (2 + alpha) /
           (1 + (1 - VEL_C) * Math.cos(theta) + VEL_C * Math.cos(phi)),
         sigma = (2 - alpha) /
-          (1 + (1 - VEL_C) * Math.cos(phi) + VEL_C * Math.cos(theta));
+          (1 + (1 - VEL_C) * Math.cos(phi) + VEL_C * Math.cos(theta)),
+        out = d * rho / 3,
+        arr = d * sigma / 3;
+    if (out > maxOut) out = maxOut;
+    if (arr > maxIn) arr = maxIn;
     return {
       p0: p0,
-      c1: [p0[0] + d * rho / 3 * Math.cos(theta + om),
-           p0[1] + d * rho / 3 * Math.sin(theta + om)],
-      c2: [p1[0] - d * sigma / 3 * Math.cos(om - phi),
-           p1[1] - d * sigma / 3 * Math.sin(om - phi)],
+      c1: [p0[0] + out * Math.cos(theta + om),
+           p0[1] + out * Math.sin(theta + om)],
+      c2: [p1[0] - arr * Math.cos(om - phi),
+           p1[1] - arr * Math.sin(om - phi)],
       p3: p1
     };
   }
@@ -82718,7 +82789,7 @@ ${svg}
     return name == 'rectangle' || name == 'rectangles' || name == 'filter' && opts.cleanup;
   }
 
-  var version = "0.7.63";
+  var version = "0.7.65";
 
   // 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.63",
+  "version": "0.7.65",
   "description": "A tool for editing geospatial data for mapping and GIS.",
   "keywords": [
     "shapefile",

package/www/mapshaper-gui.js

@@ -16663,10 +16663,15 @@
   //   aligned: whether it carries a label-align (see below)
   // delta: {dx, dy} -- how far the pointer has moved, in the same space.
   //
-  // Returns {dx, dy, text-anchor, x}, where x is where the text will be drawn
-  // once the other three are written -- the same as dx except on an aligned
-  // label. The three have to be written together: applying dx without its
-  // text-anchor moves the text by half its own width or by all of it.
+  // Returns two descriptions of the same placement:
+  //
+  //   dx, dy, text-anchor:  what the drag writes to the record. The three have to
+  //     be written together: applying dx without its text-anchor moves the text
+  //     by half its own width or by all of it.
+  //   x, anchor:  where the text sits and how it is justified while it is drawn,
+  //     which is what the preview writes onto the rendered label. The same as
+  //     dx and text-anchor except on an aligned label, whose stored offset is
+  //     measured against a justification it is not drawn with.
   function getOffsetDragValues(start, delta) {
     var width = start.width > 0 ? start.width : 0;
     var drawnAnchor = normalizeAnchor(start.anchor);
@@ -16685,12 +16690,18 @@
     // if the alignment were later removed.
     var anchor = start.aligned ? 'start' :
       width > 0 ? getAnchorForCentre(left + width / 2, width) : drawnAnchor;
+    // An aligned label goes on being drawn with the anchor its alignment gives
+    // it, whatever the drag writes: the alignment is unchanged, so the renderer
+    // will justify it the same way afterwards. Drawing it as 'start' instead
+    // would slide the text right by half its width or by all of it for the
+    // length of the drag, and drop it back on release.
+    var drawn = start.aligned ? drawnAnchor : anchor;
     return {
       dx: round$1(left + anchorOffsets[anchor] * width),
       dy: round$1(start.dy + delta.dy),
       'text-anchor': anchor,
-      x: round$1(start.aligned ? start.dx + delta.dx :
-        left + anchorOffsets[anchor] * width)
+      x: round$1(left + anchorOffsets[drawn] * width),
+      anchor: drawn
     };
   }
 
@@ -17070,8 +17081,12 @@
         applyInlineCss(cssInput.node().value.trim());
       });
 
+      // The caption for the grid and the drag-mode toggle below it, and what
+      // gives Fixed|Draggable something to be an adjective of. "Position" read as
+      // the label's own position -- which a drag moves in either mode -- and made
+      // Fixed sound like a lock on a label that is still perfectly draggable.
       var positionRow = El('label').addClass('label-style-row').appendTo(textSection);
-      El('span').appendTo(positionRow).text('Position');
+      El('span').appendTo(positionRow).text('Offset from anchor');
 
       // Whether the label has a symbol is one question and which symbol it has is
       // another, so the first is a switch on the section's heading rather than a
@@ -25332,6 +25347,9 @@
   // See docs/development/label-tool-design.md.
 
   var SVG_NS$2 = 'http://www.w3.org/2000/svg';
+  // How far outside its text a label's outline is drawn. Exported because the
+  // tool grabs a label by the same box: what looks like the object is what takes
+  // a drag on it.
   var BOX_PADDING = 3;
   var ANCHOR_RADIUS = 3.5;
   var KNOT_RADIUS = 3;
@@ -26524,7 +26542,10 @@
       // ended.
       setMultilineAttribute(nodes.text, 'x', o.values.x);
       nodes.text.setAttribute('y', o.values.dy);
-      nodes.text.setAttribute('text-anchor', o.values['text-anchor']);
+      // The anchor the label is drawn with, not the one the drag writes: on an
+      // aligned label the two differ, and the stored one belongs with the stored
+      // dx rather than with the x being previewed here.
+      nodes.text.setAttribute('text-anchor', o.values.anchor);
       // The cue is drawn around the text rather than moved with it, so it has to
       // be rebuilt to follow -- one getBBox on one label per mouse move.
       selection.refresh(true);
@@ -26679,9 +26700,34 @@
       hoverTextId = id > -1 && (!hoverHandle || glyphsOutrankHandle(id)) ? id : -1;
     }
 
+    // The exception is about the pointer being on the glyphs, not about the mode:
+    // an offset label's anchor is out from under its text, and taking the handle
+    // away there left it with no anchor handle at all -- dragging the symbol of a
+    // label positioned ne slid its text instead of moving the label.
     function glyphsOutrankHandle(id) {
       return hoverHandle.id == id && labelTextIsDraggable(gui) &&
-        !isPathLabel(hit.getHitTarget(), id);
+        !isPathLabel(hit.getHitTarget(), id) && pointerIsOverText(id);
+    }
+
+    // Whether the pointer is within the box drawn around a label's text -- the
+    // outline the selection cue draws, padding and all, so that the thing on
+    // screen that says "this is the object" is the thing that takes the drag.
+    //
+    // From the last hover rather than from an event, because this is asked from
+    // the hit control's 'change' as well, which arrives without a position; the
+    // pointer has not moved since the hover that preceded it.
+    function pointerIsOverText(id) {
+      var target = hit.getHitTarget();
+      var shapes = target && getDisplayShapes(target);
+      var shp = shapes && shapes[id];
+      var nodes = findLabelNodes(target, id);
+      var box = nodes && !nodes.textPath ? measureNode(nodes.text) : null;
+      var pix = hoverPoint && ext.translateCoords(hoverPoint[0], hoverPoint[1]);
+      var p;
+      if (!box || !pix || !shp) return false;
+      p = getLabelSpacePoint(shp[0], {x: pix[0], y: pix[1]});
+      return p.x >= box.x - BOX_PADDING && p.x <= box.x + box.width + BOX_PADDING &&
+        p.y >= box.y - BOX_PADDING && p.y <= box.y + box.height + BOX_PADDING;
     }
 
     // The label a drag on the glyphs would act on, or -1. Only a selected label

package/www/mapshaper.js

@@ -27981,6 +27981,12 @@
   // invariant under translation, rotation and scaling (Hobby 1986), which is
   // what lets the tool fit in display coordinates while storing knots in map
   // coordinates.
+  //
+  // Left alone, the method bulges: a hard turn followed by a much shorter
+  // segment throws the long segment into a wide arc, several times the length of
+  // the short one. Two limits below hold that in, MAX_HANDLE and
+  // MAX_CHORD_RATIO. Both are inert on a path whose chords are of comparable
+  // length, so an ordinary label path is fitted exactly as Hobby describes.
 
   // Curl controls how the curve behaves at the two ends of a run. At 0 it
   // approaches a straight line there; at 1 (Metafont's default) it approaches a
@@ -28068,6 +28074,24 @@
       VEL_B = 1 / 16,
       VEL_C = (3 - Math.sqrt(5)) / 2;
 
+  // Longest a control point may sit from its knot, as a fraction of the chord
+  // length that handleLimit() works out for it. See "Bulge" in the design doc: a
+  // hard turn followed by a short segment otherwise throws the long segment into
+  // a wide arc, which during editing is most of the time, because a short
+  // segment is what a half-dragged knot leaves behind.
+  //
+  // The value is a floor, not a preference. Four points on a circle want 0.3905,
+  // which is the roundest any sensible path asks for, so a limit just above it
+  // never touches a curve that was not already misbehaving.
+  var MAX_HANDLE = 0.4;
+
+  // How much longer one chord may be than its neighbour *for the purposes of the
+  // solve*. Hobby equalizes mock curvature across each knot, and a short chord
+  // carries a lot of curvature, so without this a short segment dictates a wide
+  // arc to a long one. Capping the ratio limits how far that reaches without
+  // moving any knot or touching the curve where the chords are even.
+  var MAX_CHORD_RATIO = 1.5;
+
   // Fits a run of knots, returning a cubic per interval.
   function fitRun(pts) {
     var n = pts.length - 1, // segment count
@@ -28084,16 +28108,54 @@
     psi.push(0);
     for (i = 1; i < n; i++) psi.push(wrapAngle(om[i] - om[i - 1]));
 
-    theta = solveDepartureAngles(dd, psi, n);
+    theta = solveDepartureAngles(evenOutChords(dd, n), psi, n);
     phi = getArrivalAngles(theta, psi, n);
 
     for (i = 0; i < n; i++) {
       segments.push(buildSegment(pts[i], pts[i + 1], dd[i], om[i],
-        theta[i], phi[i + 1]));
+        theta[i], phi[i + 1],
+        handleLimit(dd[i], i > 0 ? dd[i - 1] : Infinity),
+        handleLimit(dd[i], i < n - 1 ? dd[i + 1] : Infinity)));
     }
     return segments;
   }
 
+  // Longest a handle may be at one end of a segment whose own chord is @own and
+  // whose neighbour across that knot is @neighbor. (At the first and last knot
+  // of a run there is no neighbour, and the segment's own chord is the measure.)
+  //
+  // The scale is the geometric mean of the two, rather than the shorter of them.
+  // Measuring against the shorter alone holds the bulge down just as well, but
+  // it makes a long segment meeting a short one spend nearly all of its shape at
+  // its far end: on a 490-unit arm meeting a 50-unit leg the two handles came
+  // out 9.8:1, so the arm ran almost straight and then hooked hard into the
+  // knot, and the curvature either side of that knot differed by a factor of 14.
+  // The geometric mean gives the long segment a handle in proportion to how
+  // lopsided the pair actually is, which brings the same case to 3.1:1 and the
+  // curvature to within a factor of 1.4 -- about what Hobby's mock curvature
+  // leaves on an ordinary path anyway -- for two points of extra bulge.
+  function handleLimit(own, neighbor) {
+    return MAX_HANDLE * Math.sqrt(own * Math.min(own, neighbor));
+  }
+
+  // The chord lengths the solve sees, with the ratio between neighbours held to
+  // MAX_CHORD_RATIO. Each length becomes the smallest that any chord permits it
+  // to be, allowing for a factor of MAX_CHORD_RATIO per step -- a forward pass
+  // and a backward pass compute that exactly, so this needs no iteration.
+  //
+  // Only the tangent directions are affected. The curve is still built on the
+  // true chord lengths.
+  function evenOutChords(dd, n) {
+    var out = dd.concat(), i;
+    for (i = 1; i < n; i++) {
+      if (out[i] > out[i - 1] * MAX_CHORD_RATIO) out[i] = out[i - 1] * MAX_CHORD_RATIO;
+    }
+    for (i = n - 2; i >= 0; i--) {
+      if (out[i] > out[i + 1] * MAX_CHORD_RATIO) out[i] = out[i + 1] * MAX_CHORD_RATIO;
+    }
+    return out;
+  }
+
   // The tridiagonal system of Hobby's mock-curvature conditions, in the
   // departure angle at each knot measured from the chord leaving it. Written for
   // unit tension throughout; the general form carries a tension per knot, which
@@ -28137,21 +28199,30 @@
 
   // Turns a pair of angles into a cubic, by way of Hobby's velocity functions --
   // how far along each tangent the control point sits, as a multiple of a third
-  // of the chord.
-  function buildSegment(p0, p1, d, om, theta, phi) {
+  // of the chord -- with each distance held to the caller's limit.
+  //
+  // Shortening a handle leaves its direction alone, so the tangent the two
+  // segments share at a knot is untouched and the curve stays smooth through it.
+  // What it gives up is Hobby's mock-curvature match across that knot, and only
+  // at a knot lopsided enough for the limit to bite.
+  function buildSegment(p0, p1, d, om, theta, phi, maxOut, maxIn) {
     var alpha = VEL_A * (Math.sin(theta) - VEL_B * Math.sin(phi)) *
           (Math.sin(phi) - VEL_B * Math.sin(theta)) *
           (Math.cos(theta) - Math.cos(phi)),
         rho = (2 + alpha) /
           (1 + (1 - VEL_C) * Math.cos(theta) + VEL_C * Math.cos(phi)),
         sigma = (2 - alpha) /
-          (1 + (1 - VEL_C) * Math.cos(phi) + VEL_C * Math.cos(theta));
+          (1 + (1 - VEL_C) * Math.cos(phi) + VEL_C * Math.cos(theta)),
+        out = d * rho / 3,
+        arr = d * sigma / 3;
+    if (out > maxOut) out = maxOut;
+    if (arr > maxIn) arr = maxIn;
     return {
       p0: p0,
-      c1: [p0[0] + d * rho / 3 * Math.cos(theta + om),
-           p0[1] + d * rho / 3 * Math.sin(theta + om)],
-      c2: [p1[0] - d * sigma / 3 * Math.cos(om - phi),
-           p1[1] - d * sigma / 3 * Math.sin(om - phi)],
+      c1: [p0[0] + out * Math.cos(theta + om),
+           p0[1] + out * Math.sin(theta + om)],
+      c2: [p1[0] - arr * Math.cos(om - phi),
+           p1[1] - arr * Math.sin(om - phi)],
       p3: p1
     };
   }
@@ -82718,7 +82789,7 @@ ${svg}
     return name == 'rectangle' || name == 'rectangles' || name == 'filter' && opts.cleanup;
   }
 
-  var version = "0.7.63";
+  var version = "0.7.65";
 
   // 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.