mapshaper 0.5.89 → 0.5.93

package/www/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.5.88";
+  var VERSION = "0.5.92";
 
 
   var utils = /*#__PURE__*/Object.freeze({
@@ -994,15 +994,23 @@
   }
 
   function copyElements(src, i, dest, j, n, rev) {
-    if (src === dest && j > i) error ("copy error");
+    var same = src == dest || src.buffer && src.buffer == dest.buffer;
     var inc = 1,
-        offs = 0;
+        offs = 0,
+        k;
     if (rev) {
+      if (same) error('copy error');
       inc = -1;
       offs = n - 1;
     }
-    for (var k=0; k<n; k++, offs += inc) {
-      dest[k + j] = src[i + offs];
+    if (same && j > i) {
+      for (k=n-1; k>=0; k--) {
+        dest[j + k] = src[i + k];
+      }
+    } else {
+      for (k=0; k<n; k++, offs += inc) {
+        dest[k + j] = src[i + offs];
+      }
     }
   }
 
@@ -1240,7 +1248,8 @@
   // print a message to stdout
   function print() {
     STDOUT = true; // tell logArgs() to print to stdout, not stderr
-    message.apply(null, arguments);
+    // calling message() adds the "[command name]" prefix
+    _message(utils.toArray(arguments));
     STDOUT = false;
   }
 
@@ -1755,6 +1764,69 @@
     return [xmin, ymin, xmax, ymax];
   }
 
+  function deleteVertex(arcs, i) {
+    var data = arcs.getVertexData();
+    var nn = data.nn;
+    var n = data.xx.length;
+    // avoid re-allocating memory
+    var xx2 = new Float64Array(data.xx.buffer, 0, n-1);
+    var yy2 = new Float64Array(data.yy.buffer, 0, n-1);
+    var count = 0;
+    var found = false;
+    for (var j=0; j<nn.length; j++) {
+      count += nn[j];
+      if (count >= i && !found) { // TODO: confirm this
+        nn[j] = nn[j] - 1;
+        found = true;
+      }
+    }
+    utils.copyElements(data.xx, 0, xx2, 0, i);
+    utils.copyElements(data.yy, 0, yy2, 0, i);
+    utils.copyElements(data.xx, i+1, xx2, i, n-i-1);
+    utils.copyElements(data.yy, i+1, yy2, i, n-i-1);
+    arcs.updateVertexData(nn, xx2, yy2, null);
+  }
+
+  function insertVertex(arcs, i, p) {
+    // TODO: add extra bytes to the buffers, to reduce new memory allocation
+    var data = arcs.getVertexData();
+    var nn = data.nn;
+    var n = data.xx.length;
+    var count = 0;
+    var found = false;
+    var xx2, yy2;
+    // avoid re-allocating memory on each insertion
+    if (data.xx.buffer.byteLength >= data.xx.length * 8 + 8) {
+      xx2 = new Float64Array(data.xx.buffer, 0, n+1);
+      yy2 = new Float64Array(data.yy.buffer, 0, n+1);
+    } else {
+      xx2 = new Float64Array(new ArrayBuffer((n + 20) * 8), 0, n+1);
+      yy2 = new Float64Array(new ArrayBuffer((n + 20) * 8), 0, n+1);
+    }
+    for (var j=0; j<nn.length; j++) {
+      count += nn[j];
+      if (count >= i && !found) { // TODO: confirm this
+        nn[j] = nn[j] + 1;
+        found = true;
+      }
+    }
+    utils.copyElements(data.xx, 0, xx2, 0, i);
+    utils.copyElements(data.yy, 0, yy2, 0, i);
+    utils.copyElements(data.xx, i, xx2, i+1, n-i);
+    utils.copyElements(data.yy, i, yy2, i+1, n-i);
+    xx2[i] = p[0];
+    yy2[i] = p[1];
+    arcs.updateVertexData(nn, xx2, yy2, null);
+  }
+
+  var ArcUtils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    absArcId: absArcId,
+    calcArcBounds: calcArcBounds,
+    deleteVertex: deleteVertex,
+    insertVertex: insertVertex
+  });
+
   var WGS84 = {
     // https://en.wikipedia.org/wiki/Earth_radius
     SEMIMAJOR_AXIS: 6378137,
@@ -2157,6 +2229,7 @@
   function getPointToPathInfo(px, py, ids, arcs) {
     var iter = arcs.getShapeIter(ids);
     var pPathSq = Infinity;
+    var arcId;
     var ax, ay, bx, by, axmin, aymin, bxmin, bymin, pabSq;
     if (iter.hasNext()) {
       ax = axmin = bxmin = iter.x;
@@ -2168,6 +2241,7 @@
       pabSq = pointSegDistSq2(px, py, ax, ay, bx, by);
       if (pabSq < pPathSq) {
         pPathSq = pabSq;
+        arcId = iter._ids[iter._i]; // kludge
         axmin = ax;
         aymin = ay;
         bxmin = bx;
@@ -2179,7 +2253,8 @@
     if (pPathSq == Infinity) return {distance: Infinity};
     return {
       segment: [[axmin, aymin], [bxmin, bymin]],
-      distance: Math.sqrt(pPathSq)
+      distance: Math.sqrt(pPathSq),
+      arcId: arcId
     };
   }
 
@@ -2187,11 +2262,20 @@
   // Return unsigned distance of a point to the nearest point on a polygon or polyline path
   //
   function getPointToShapeDistance(x, y, shp, arcs) {
-    var minDist = (shp || []).reduce(function(minDist, ids) {
-      var pathDist = getPointToPathDistance(x, y, ids, arcs);
-      return Math.min(minDist, pathDist);
-    }, Infinity);
-    return minDist;
+    var info = getPointToShapeInfo(x, y, shp, arcs);
+    return info ? info.distance : Infinity;
+  }
+
+  function getPointToShapeInfo(x, y, shp, arcs) {
+    return (shp || []).reduce(function(memo, ids) {
+      var pathInfo = getPointToPathInfo(x, y, ids, arcs);
+      if (!memo || pathInfo.distance < memo.distance) return pathInfo;
+      return memo;
+    }, null) || {
+      distance: Infinity,
+      arcId: -1,
+      segment: null
+    };
   }
 
   // @ids array of arc ids
@@ -2276,6 +2360,7 @@
     getPointToPathDistance: getPointToPathDistance,
     getPointToPathInfo: getPointToPathInfo,
     getPointToShapeDistance: getPointToShapeDistance,
+    getPointToShapeInfo: getPointToShapeInfo,
     getAvgPathXY: getAvgPathXY,
     getMaxPath: getMaxPath,
     countVerticesInPath: countVerticesInPath,
@@ -4908,6 +4993,7 @@
     this._n = 0;
     this.x = 0;
     this.y = 0;
+    this.i = -1;
   }
 
   ShapeIter.prototype.hasNext = function() {
@@ -4918,6 +5004,7 @@
     if (arc.hasNext()) {
       this.x = arc.x;
       this.y = arc.y;
+      this.i = arc.i;
       return true;
     }
     this.nextArc();
@@ -5376,6 +5463,10 @@
       };
     };
 
+    this.getVertex2 = function(i) {
+      return [_xx[i], _yy[i]];
+    };
+
     // @nth: index of vertex. ~(idx) starts from the opposite endpoint
     this.indexOfVertex = function(arcId, nth) {
       var absId = arcId < 0 ? ~arcId : arcId,
@@ -5480,6 +5571,8 @@
       }
     };
 
+    this.isFlat = function() { return !_zz; };
+
     this.getRetainedInterval = function() {
       return _zlimit;
     };
@@ -9356,6 +9449,18 @@
     };
     addGetters(obj, getters);
     addBBoxGetter(obj, lyr, arcs);
+    obj.field_exists = function(name) {
+      return lyr.data && lyr.data.fieldExists(name) ? true : false;
+    };
+    obj.field_type = function(name) {
+      return lyr.data && getColumnType(name, lyr.data.getRecords()) || null;
+    };
+    obj.field_includes = function(name, val) {
+      if (!lyr.data) return false;
+      return lyr.data.getRecords().some(function(rec) {
+        return rec && (rec[name] === val);
+      });
+    };
     return obj;
   }
 
@@ -20598,6 +20703,10 @@ ${svg}
       .option('target', targetOpt)
       .validate(validateExpressionOpt);
 
+    parser.command('print')
+      .describe('print a message to stdout')
+      .flag('multi_arg');
+
     parser.command('projections')
       .describe('print list of supported projections');
 
@@ -23413,7 +23522,16 @@ ${svg}
     // should be in gui-model.js, moved here for testing
     this.getActiveLayer = function() {
       var targ = (this.getDefaultTargets() || [])[0];
-      return targ ? {layer: targ.layers[0], dataset: targ.dataset} : null;
+      // var lyr = targ.layers[0];
+      // Reasons to select the last layer of a multi-layer target:
+      // * This layer was imported last
+      // * This layer is displayed on top of other layers
+      // * This layer is at the top of the layers list
+      // * In TopoJSON input, it makes sense to think of the last object/layer
+      //   as the topmost one -- it corresponds to the painter's algorithm and
+      //   the way that objects are ordered in SVG.
+      var lyr = targ.layers[targ.layers.length - 1];
+      return targ ? {layer: lyr, dataset: targ.dataset} : null;
     };
 
     function layerObject(lyr, dataset) {
@@ -27150,7 +27268,7 @@ ${svg}
   }
 
   function samePoint(a, b) {
-    return a[0] === b[0] && a[1] === b[1];
+    return a && b && a[0] === b[0] && a[1] === b[1];
   }
 
   function isClosedPath(arr) {
@@ -27764,11 +27882,15 @@ ${svg}
   }
 
   function getCategoricalColorScheme(name, n) {
+    var colors;
     initSchemes();
-    if (index.categorical.includes(name) === false) {
-      stop(name, 'is not a categorical color scheme');
+    if (!isColorSchemeName(name)) {
+      stop('Unknown color scheme name:', name);
+    } else if (isCategoricalColorScheme(name)) {
+      colors = ramps[name] || require('d3-scale-chromatic')['scheme' + name];
+    } else {
+      colors = getColorRamp(name, n);
     }
-    var colors = ramps[name] || require('d3-scale-chromatic')['scheme' + name];
     if (n > colors.length) {
       stop(name, 'does not contain', n, 'colors');
     }
@@ -27781,6 +27903,11 @@ ${svg}
       index.diverging.includes(name) || index.rainbow.includes(name);
   }
 
+  function isCategoricalColorScheme(name) {
+    initSchemes();
+    return index.categorical.includes(name);
+  }
+
   function getColorRamp(name, n, stops) {
     initSchemes();
     var lib = require('d3-scale-chromatic');
@@ -28270,7 +28397,7 @@ ${svg}
     };
   }
 
-  function getSequentialClassifier$1(classValues, nullValue, dataValues, opts) {
+  function getSequentialClassifier$1(classValues, nullValue, dataValues, method, opts) {
     var numValues = classValues.length;
     var numBuckets = opts.continuous ? numValues - 1 : numValues;
 
@@ -28278,7 +28405,6 @@ ${svg}
     // discreetly classed values
     var numBreaks = numBuckets - 1;
     var round = opts.precision ? getRoundingFunction(opts.precision) : null;
-    var method = opts.method || 'quantile';
     var breaks, classifier, dataToClass, classToValue;
 
     if (round) {
@@ -28883,34 +29009,35 @@ ${svg}
     var opts = optsArg || {};
     var records = lyr.data && lyr.data.getRecords();
     var nullValue = opts.null_value || null;
-    var looksLikeColors = !!opts.colors || !!opts.color_scheme;
+    var valuesAreColors = !!opts.colors || !!opts.color_scheme;
     var colorScheme;
-    var classValues, classifyByValue, classifyById;
-    var numBuckets, numValues;
+    var values, classifyByValue, classifyById;
+    var numClasses, numValues;
     var dataField, outputField;
+    var method;
 
     // validate explicitly set classes
     if (opts.classes) {
       if (!utils.isInteger(opts.classes) || opts.classes > 1 === false) {
         stop('Invalid number of classes:', opts.classes, '(expected a value greater than 1)');
       }
-      numBuckets = opts.classes;
+      numClasses = opts.classes;
     }
 
     // TODO: better validation of breaks values
     if (opts.breaks) {
-      numBuckets = opts.breaks.length + 1;
+      numClasses = opts.breaks.length + 1;
     }
 
     if (opts.index_field) {
       dataField = opts.index_field;
-      if (numBuckets > 0 === false) {
+      if (numClasses > 0 === false) {
         stop('The index-field= option requires the classes= option to be set');
       }
       // You can't infer the number of classes by looking at index values;
       // this can cause unwanted interpolation if one or more values are
       // not present in the index field
-      // numBuckets = validateClassIndexField(records, opts.index_field);
+      // numClasses = validateClassIndexField(records, opts.index_field);
 
     } else if (opts.field) {
       dataField = opts.field;
@@ -28921,7 +29048,19 @@ ${svg}
       opts.categories = getUniqFieldValues(records, dataField);
     }
 
-    if (opts.method == 'non-adjacent') {
+    // get classification method
+    //
+    if (opts.method) {
+      method = opts.method;
+    } else if (opts.categories) {
+      method = 'categorical';
+    } else if (opts.index_field) {
+      method = 'indexed';
+    } else {
+      method = 'quantile'; // TODO: validate data field
+    }
+
+    if (method == 'non-adjacent') {
       if (lyr.geometry_type != 'polygon') {
         stop('The non-adjacent option requires a polygon layer');
       }
@@ -28934,8 +29073,8 @@ ${svg}
       requireDataField(lyr.data, dataField);
     }
 
-    if (numBuckets) {
-      numValues = opts.continuous ? numBuckets + 1 : numBuckets;
+    if (numClasses) {
+      numValues = opts.continuous ? numClasses + 1 : numClasses;
     }
 
     // support both deprecated color-scheme= option and colors=<color-scheme> syntax
@@ -28950,39 +29089,44 @@ ${svg}
       opts.colors.forEach(parseColor); // validate colors -- error if unparsable
     }
 
+    /// get values (usually colors)
+    ///
     if (colorScheme) {
-      // using a named color scheme: generate a ramp
+      if (method == 'non-adjacent') {
+        numClasses = numValues = numClasses || 5;
+        values = getCategoricalColorScheme(colorScheme, numValues);
+
+      } else if (method == 'categorical') {
+        values = getCategoricalColorScheme(colorScheme, opts.categories.length);
+        numClasses = numValues = values.length;
 
-      if (opts.categories) {
-        classValues = getCategoricalColorScheme(colorScheme, opts.categories.length);
-        numBuckets = numValues = classValues.length;
       } else {
-        if (!numBuckets) {
+        if (!numClasses) {
           // stop('color-scheme= option requires classes= or breaks=');
-          numBuckets = 4; // use a default number of classes
-          numValues = opts.continuous ? numBuckets + 1 : numBuckets;
+          numClasses = 4; // use a default number of classes
+          numValues = opts.continuous ? numClasses + 1 : numClasses;
         }
-        classValues = getColorRamp(colorScheme, numValues, opts.stops);
+        values = getColorRamp(colorScheme, numValues, opts.stops);
       }
 
     } else if (opts.colors || opts.values) {
-      classValues = opts.values ? parseValues(opts.values) : opts.colors;
+      values = opts.values ? parseValues(opts.values) : opts.colors;
       if (!numValues) {
-        numValues = classValues.length;
+        numValues = values.length;
       }
-      if ((classValues.length != numValues || opts.stops) && numValues > 1) {
+      if ((values.length != numValues || opts.stops) && numValues > 1) {
         // TODO: handle numValues == 1
         // TODO: check for non-interpolatable value types (e.g. boolean, text)
-        classValues = interpolateValuesToClasses(classValues, numValues, opts.stops);
+        values = interpolateValuesToClasses(values, numValues, opts.stops);
       }
 
     } else if (numValues > 1) {
       // no values were given: assign indexes for each class
-      classValues = getIndexValues(numValues);
+      values = getIndexValues(numValues);
       nullValue = -1;
     }
 
-    if (looksLikeColors) {
+    if (valuesAreColors) {
       nullValue = nullValue || '#eee';
     }
 
@@ -28991,24 +29135,24 @@ ${svg}
     }
 
     if (opts.invert) {
-      classValues = classValues.concat().reverse();
+      values = values.concat().reverse();
     }
 
-    if (looksLikeColors) {
-      message('Colors:', formatValuesForLogging(classValues));
+    if (valuesAreColors) {
+      message('Colors:', formatValuesForLogging(values));
     }
 
     // get a function to convert input data to class indexes
     //
-    if (opts.method == 'non-adjacent') {
-      classifyById = getNonAdjacentClassifier(lyr, dataset, classValues);
+    if (method == 'non-adjacent') {
+      classifyById = getNonAdjacentClassifier(lyr, dataset, values);
     } else if (opts.index_field) {
       // data is pre-classified... just read the index from a field
-      classifyByValue = getIndexedClassifier(classValues, nullValue, opts);
-    } else if (opts.categories) {
-      classifyByValue = getCategoricalClassifier(classValues, nullValue, opts);
+      classifyByValue = getIndexedClassifier(values, nullValue, opts);
+    } else if (method == 'categorical') {
+      classifyByValue = getCategoricalClassifier(values, nullValue, opts);
     } else {
-      classifyByValue = getSequentialClassifier$1(classValues, nullValue, getFieldValues(records, dataField), opts);
+      classifyByValue = getSequentialClassifier$1(values, nullValue, getFieldValues(records, dataField), method, opts);
     }
 
     if (classifyByValue) {
@@ -29021,7 +29165,7 @@ ${svg}
 
     // get the name of the output field
     //
-    if (looksLikeColors) {
+    if (valuesAreColors) {
       outputField = lyr.geometry_type == 'polyline' ? 'stroke' : 'fill';
     } else {
       outputField = 'class';
@@ -34908,16 +35052,7 @@ ${svg}
     return findVertexIds(p2.x, p2.y, arcs);
   }
 
-  // Given a location @p (e.g. corresponding to the mouse pointer location),
-  // find the midpoint of two vertices on @shp suitable for inserting a new vertex,
-  // but only if:
-  //   1. point @p is closer to the midpoint than either adjacent vertex
-  //   2. the segment containing @p is longer than a minimum distance in pixels.
-  //
-  function findInsertionPoint(p, shp, arcs, pixelSize) {
-    var p2 = findNearestVertex(p[0], p[1], shp, arcs);
 
-  }
 
   function snapVerticesToPoint(ids, p, arcs, final) {
     ids.forEach(function(idx) {
@@ -34998,7 +35133,7 @@ ${svg}
   function findNearestVertex(x, y, shp, arcs, spherical) {
     var calcLen = spherical ? geom.greatCircleDistance : geom.distance2D,
         minLen = Infinity,
-        minX, minY, dist, iter;
+        minX, minY, vId, dist, iter;
     for (var i=0; i<shp.length; i++) {
       iter = arcs.getShapeIter(shp[i]);
       while (iter.hasNext()) {
@@ -35007,16 +35142,31 @@ ${svg}
           minLen = dist;
           minX = iter.x;
           minY = iter.y;
+          vId = iter.i;
         }
       }
     }
-    return minLen < Infinity ? {x: minX, y: minY} : null;
+    return minLen < Infinity ? {x: minX, y: minY, i: vId} : null;
+  }
+
+  // v: vertex in {x, y, i} format
+  function findAdjacentVertex(v, shp, arcs, offs) {
+    var p, i;
+    var arcEnd = offs == 1 && vertexIsArcEnd(v.i, arcs);
+    var arcStart = offs == -1 && vertexIsArcStart(v.i, arcs);
+    if (arcEnd || arcStart) return null;
+    i = v.i + offs;
+    p = getVertexCoords(i, arcs);
+    return {
+      i: i,
+      x: p[0],
+      y: p[1]
+    };
   }
 
   var VertexUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
     findNearestVertices: findNearestVertices,
-    findInsertionPoint: findInsertionPoint,
     snapVerticesToPoint: snapVerticesToPoint,
     snapPointToArcEndpoint: snapPointToArcEndpoint,
     findVertexIds: findVertexIds,
@@ -35024,7 +35174,8 @@ ${svg}
     vertexIsArcEnd: vertexIsArcEnd,
     vertexIsArcStart: vertexIsArcStart,
     setVertexCoords: setVertexCoords,
-    findNearestVertex: findNearestVertex
+    findNearestVertex: findNearestVertex,
+    findAdjacentVertex: findAdjacentVertex
   });
 
   // Returns x,y coordinates of the point that is at the midpoint of each polyline feature
@@ -36633,6 +36784,10 @@ ${svg}
     };
   }
 
+  cmd.print = function(msgArg) {
+    print(msgArg || '');
+  };
+
   cmd.renameLayers = function(layers, names, catalog) {
     if (names && names.join('').indexOf('=') > -1) {
       renameByAssignment(names, catalog);
@@ -39140,7 +39295,7 @@ ${svg}
         }
         if (!(name == 'graticule' || name == 'i' || name == 'help' ||
             name == 'point-grid' || name == 'shape' || name == 'rectangle' ||
-            name == 'include')) {
+            name == 'include' || name == 'print')) {
           throw new UserError("No data is available");
         }
       }
@@ -39325,6 +39480,9 @@ ${svg}
       } else if (name == 'polygons') {
         outputLayers = cmd.polygons(targetLayers, targetDataset, opts);
 
+      } else if (name == 'print') {
+        cmd.print(command._.join(' '));
+
       } else if (name == 'proj') {
         initProjLibrary(opts, function() {
           var err = null;
@@ -40202,6 +40360,7 @@ ${svg}
     AnchorPoints,
     ArcClassifier,
     ArcDissolve,
+    ArcUtils,
     Bbox2Clipping,
     BinArray$1,
     BufferCommon,