mapshaper 0.6.24 → 0.6.26

package/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.6.24";
+  var VERSION = "0.6.26";
 
 
   var utils = /*#__PURE__*/Object.freeze({
@@ -2449,6 +2449,17 @@
     getPathCentroid: getPathCentroid
   });
 
+  function testSegmentBoundsIntersection(a, b, bb) {
+    if (bb.containsPoint(a[0], a[1])) {
+      return true;
+    }
+    return !!(
+      geom.segmentIntersection(a[0], a[1], b[0], b[1], bb.xmin, bb.ymin, bb.xmin, bb.ymax) ||
+      geom.segmentIntersection(a[0], a[1], b[0], b[1], bb.xmin, bb.ymax, bb.xmax, bb.ymax) ||
+      geom.segmentIntersection(a[0], a[1], b[0], b[1], bb.xmax, bb.ymax, bb.xmax, bb.ymin) ||
+      geom.segmentIntersection(a[0], a[1], b[0], b[1], bb.xmax, bb.ymin, bb.xmin, bb.ymin));
+  }
+
   // A compactness measure designed for testing electoral districts for gerrymandering.
   // Returns value in [0-1] range. 1 = perfect circle, 0 = collapsed polygon
   function calcPolsbyPopperCompactness(area, perimeter) {
@@ -2496,21 +2507,32 @@
   //   }, 0);
   // }
 
+  // test if a rectangle is completely enclosed in a planar polygon
+  function testBoundsInPolygon(bounds, shp, arcs) {
+    if (!shp || !testPointInPolygon(bounds.xmin, bounds.ymin, shp, arcs)) return false;
+    var isIn = true;
+    shp.forEach(function(ids) {
+      forEachSegmentInPath(ids, arcs, function(a, b, xx, yy) {
+        isIn = isIn && !testSegmentBoundsIntersection([xx[a], yy[a]], [xx[b], yy[b]], bounds);
+      });
+    });
+    return isIn;
+  }
+
   // Return true if point is inside or on boundary of a shape
   //
   function testPointInPolygon(x, y, shp, arcs) {
     var isIn = false,
         isOn = false;
-    if (shp) {
-      shp.forEach(function(ids) {
-        var inRing = testPointInRing(x, y, ids, arcs);
-        if (inRing == 1) {
-          isIn = !isIn;
-        } else if (inRing == -1) {
-          isOn = true;
-        }
-      });
-    }
+    if (!shp) return false;
+    shp.forEach(function(ids) {
+      var inRing = testPointInRing(x, y, ids, arcs);
+      if (inRing == 1) {
+        isIn = !isIn;
+      } else if (inRing == -1) {
+        isOn = true;
+      }
+    });
     return isOn || isIn;
   }
 
@@ -2518,6 +2540,8 @@
     return ay + (x - ax) * (by - ay) / (bx - ax);
   }
 
+
+
   // Test if point (x, y) is inside, outside or on the boundary of a polygon ring
   // Return 0: outside; 1: inside; -1: on boundary
   //
@@ -2708,6 +2732,7 @@
     getShapeArea: getShapeArea,
     getPlanarShapeArea: getPlanarShapeArea,
     getSphericalShapeArea: getSphericalShapeArea,
+    testBoundsInPolygon: testBoundsInPolygon,
     testPointInPolygon: testPointInPolygon,
     testPointInRing: testPointInRing,
     testRayIntersection: testRayIntersection,
@@ -7251,7 +7276,7 @@
   			let size = source.length;
   			let value = this ? this.unpack(source, size) : defaultUnpackr.unpack(source, size);
   			if (forEach) {
-  				forEach(value);
+  				if (forEach(value) === false) return;
   				while(position$1 < size) {
   					lastPosition = position$1;
   					if (forEach(checkedRead()) === false) {
@@ -8193,7 +8218,7 @@
   let safeEnd;
   let bundledStrings = null;
   let writeStructSlots;
-  const MAX_BUNDLE_SIZE = 0xf000;
+  const MAX_BUNDLE_SIZE = 0x5500; // maximum characters such that the encoded bytes fits in 16 bits.
   const hasNonLatin = /[\u0080-\uFFFF]/;
   const RECORD_SYMBOL = Symbol('record-id');
   class Packr extends Unpackr {
@@ -8222,7 +8247,7 @@
   		if (maxSharedStructures > 8160)
   			throw new Error('Maximum maxSharedStructure is 8160')
   		if (options.structuredClone && options.moreTypes == undefined) {
-  			options.moreTypes = true;
+  			this.moreTypes = true;
   		}
   		let maxOwnStructures = options.maxOwnStructures;
   		if (maxOwnStructures == null)
@@ -8917,12 +8942,11 @@
   				if (notifySharedUpdate)
   					return hasSharedUpdate = true;
   				position = newPosition;
-  				if (start > 0) {
-  					pack(value);
-  					if (start == 0)
-  						return { position, targetView, target }; // indicate the buffer was re-allocated
-  				} else
-  					pack(value);
+  				let startTarget = target;
+  				pack(value);
+  				if (startTarget !== target) {
+  					return { position, targetView, target }; // indicate the buffer was re-allocated
+  				}
   				return position;
   			}, this);
   			if (newPosition === 0) // bail and go to a msgpack object
@@ -13704,6 +13728,28 @@
         }});
     }
 
+    if (hasPaths || hasPoints) {
+      addGetters(ctx, {
+        // TODO: count hole/s + containing ring as one part
+        partCount: function() {
+          var shp = lyr.shapes[_id];
+          return shp ? shp.length : 0;
+        },
+        isNull: function() {
+          return ctx.partCount === 0;
+        },
+        bounds: function() {
+          return shapeBounds().toArray();
+        },
+        height: function() {
+          return shapeBounds().height();
+        },
+        width: function() {
+          return shapeBounds().width();
+        }
+      });
+    }
+
     if (hasPaths) {
 
       ctx.bboxContainsPoint = function(x, y) {
@@ -13729,24 +13775,10 @@
         return rect.contains(bbox);
       };
 
-      addGetters(ctx, {
-        // TODO: count hole/s + containing ring as one part
-        partCount: function() {
-          return _ids ? _ids.length : 0;
-        },
-        isNull: function() {
-          return ctx.partCount === 0;
-        },
-        bounds: function() {
-          return shapeBounds().toArray();
-        },
-        height: function() {
-          return shapeBounds().height();
-        },
-        width: function() {
-          return shapeBounds().width();
-        }
-      });
+      // TODO
+      // ctx.intersectsRectangle = function(a, b, c, d) {}; // paths... points too?
+      // ctx.containsPoint = function(x, y) {}; // polygon only
+      // ctx.containedByRectangle(a, b, c, d); // paths and points... how do multipart points work?
 
       if (lyr.geometry_type == 'polyline') {
         addGetters(ctx, {
@@ -13809,7 +13841,7 @@
       }
 
     } else if (hasPoints) {
-      // TODO: add functions like bounds, isNull, pointCount
+
       Object.defineProperty(ctx, 'coordinates',
         {set: function(obj) {
           if (!obj || utils.isArray(obj)) {
@@ -13848,8 +13880,13 @@
     }
 
     function shapeBounds() {
-      if (!_bounds) {
+      if (_bounds) return _bounds;
+      if (hasPaths) {
         _bounds = arcs.getMultiShapeBounds(_ids);
+      } else if (hasPoints) {
+        _bounds = getPointFeatureBounds(lyr.shapes[_id]);
+      } else {
+        _bounds = new Bounds();
       }
       return _bounds;
     }
@@ -13857,8 +13894,8 @@
     return function(id) {
       _id = id;
       // reset stored values
+      _bounds = null;
       if (hasPaths) {
-        _bounds = null;
         _centroid = null;
         _innerXY = null;
         _ids = lyr.shapes[id];
@@ -14263,9 +14300,9 @@
   }
 
   function compileCalcExpression(lyr, arcs, exp) {
-    var rowNo = 0, colNo = 0, cols = [];
+    var rowNo = 0, colNo = 0, recId = -1, cols = [];
     var ctx1 = { // context for first phase (capturing values for each feature)
-          count: assign,
+          count: assign, // dummy function - first pass does nothing
           sum: captureNum,
           sums: capture,
           average: captureNum,
@@ -14280,6 +14317,7 @@
           max: captureNum,
           mode: capture,
           collect: capture,
+          collectIds: captureId,
           first: assignOnce,
           every: every,
           some: some,
@@ -14303,6 +14341,7 @@
           mean: wrap(utils.mean),
           mode: wrap(getMode),
           collect: wrap(pass),
+          collectIds: wrap(pass),
           first: wrap(pass),
           every: wrap(pass, false),
           some: wrap(pass, false),
@@ -14389,6 +14428,7 @@
 
     function procRecord(i) {
       if (i < 0 || i >= len) error("Invalid record index");
+      recId = i;
       calc1(i);
       rowNo++;
       colNo = 0;
@@ -14397,6 +14437,7 @@
     function noop() {}
 
     function reset() {
+      recId = -1;
       rowNo = 0;
       colNo = 0;
       cols = [];
@@ -14438,6 +14479,10 @@
     }
     */
 
+    function captureId() {
+      capture(recId);
+    }
+
     function capture(val) {
       var col;
       if (rowNo === 0) {
@@ -24602,6 +24647,21 @@ ${svg}
     // Experimental commands
     parser.section('Experimental commands (may give unexpected results)');
 
+    parser.command('add-shape')
+      .describe('')
+      .option('geojson', {
+
+      })
+      .option('coordinates', {
+
+      })
+      .option('properties', {
+
+      })
+      .option('name', nameOpt)
+      .option('target', targetOpt)
+      .option('no-replace', noReplaceOpt);
+
     parser.command('alpha-shapes')
       // .describe('convert points to alpha shapes (aka concave hulls)')
       .option('interval', {
@@ -28076,6 +28136,136 @@ ${svg}
     stashVar('input_files', job.input_files);
   }
 
+  cmd.addShape = addShape;
+
+  function addShape(targetLayers, targetDataset, opts) {
+    if (targetLayers.length > 1) {
+      stop('Command expects a single target layer');
+    }
+    var targetLyr = targetLayers[0]; // may be undefined
+    var targetType = !opts.no_replace && targetLyr && targetLyr.geometry_type || null;
+    var dataset = importGeoJSON(toFeature(opts, targetType));
+    var outputLyr = mergeDatasetsIntoDataset(targetDataset, [dataset])[0];
+    if (opts.no_replace || !targetLyr) {
+      // create new layer
+      setOutputLayerName(outputLyr, targetLyr && targetLyr.name, null, opts);
+      return [outputLyr];
+    }
+    // merge into target layer
+    return cmd.mergeLayers([targetLyr, outputLyr], {force: true});
+  }
+
+  function toFeature(opts, geomType) {
+    if (opts.geojson) {
+      return parseArg(opts.geojson);
+    }
+
+    var geom = opts.coordinates && parseCoordsAsGeometry(opts.coordinates) || null;
+
+    if (!geom) {
+      stop('Missing required shape coordinates');
+    }
+
+    if (geomType == 'point' && geom.type != 'Point') {
+      stop('Expected point coordinates, received', geom.type);
+    }
+
+    if (geomType == 'polygon' && geom.type != 'Polygon') {
+      stop('Expected polygon coordinates, received', geom.type);
+    }
+
+    if (geomType == 'polyline') {
+      if (geom.type == 'Polygon') {
+        geom.coordinates = geom.coordinates[0];
+        geom.type = 'LineString';
+      } else {
+        stop('Expected polyline coordinates, received', geom.type);
+      }
+    }
+
+    return {
+      type: 'Feature',
+      properties: parseProperties(opts.properties),
+      geometry: geom
+    };
+  }
+
+  function parseArg(obj) {
+    return typeof obj == 'string' ? JSON.parse(obj) : obj;
+  }
+
+  function parseProperties(arg) {
+    if (!arg) return null;
+    return parseArg(arg);
+  }
+
+  function isArrayOfNumbers(arr) {
+    return arr.length >= 2 && arr.every(utils.isNumber);
+  }
+
+  function isClosedPath$1(arr) {
+    return isArrayOfPoints(arr) && arr.length > 3 && samePoint$1(arr[0], arr[arr.length - 1]);
+  }
+
+  function samePoint$1(a, b) {
+    return a[0] == b[0] && a[1] == b[1];
+  }
+
+  function isArrayOfPoints(arr) {
+    return arr.every(isPoint);
+  }
+
+  function isPoint(arr) {
+    return arr && arr.length == 2 && isArrayOfNumbers(arr);
+  }
+
+  function transposeCoords(arr) {
+    var coords = [];
+    for (var i=0; i<arr.length; i+=2) {
+      coords.push([arr[i], arr[i+1]]);
+    }
+    if (!isArrayOfPoints(coords)) {
+      stop('Unable to parse x,y,x,y... coordinates');
+    }
+    return coords;
+  }
+
+  function parseCoordsAsGeometry(arg) {
+    if (typeof arg == 'string') {
+      arg = arg.trim();
+      if (!arg.startsWith('[') && !arg.endsWith(']')) {
+        arg = '[' + arg + ']';
+      }
+    }
+    var arr = parseArg(arg);
+    if (isPoint(arr)) {
+      return {
+        type: 'Point',
+        coordinates: arr
+      };
+    }
+
+    if (isArrayOfNumbers(arr)) {
+      arr = transposeCoords(arr);
+    }
+
+    if (isClosedPath$1(arr)) {
+      return {
+        type: 'Polygon',
+        coordinates: [arr]
+      };
+    }
+
+    if (isArrayOfPoints(arr)) {
+      return {
+        type: 'LineString',
+        coordinates: arr
+      };
+    }
+
+    stop('Unable to import coordinates');
+  }
+
   const epsilon = 1.1102230246251565e-16;
   const splitter = 134217729;
   const resulterrbound = (3 + 8 * epsilon) * epsilon;
@@ -29264,17 +29454,6 @@ ${svg}
     bufferIntersection: bufferIntersection
   });
 
-  function testSegmentBoundsIntersection(a, b, bb) {
-    if (bb.containsPoint(a[0], a[1])) {
-      return true;
-    }
-    return !!(
-      geom.segmentIntersection(a[0], a[1], b[0], b[1], bb.xmin, bb.ymin, bb.xmin, bb.ymax) ||
-      geom.segmentIntersection(a[0], a[1], b[0], b[1], bb.xmin, bb.ymax, bb.xmax, bb.ymax) ||
-      geom.segmentIntersection(a[0], a[1], b[0], b[1], bb.xmax, bb.ymax, bb.xmax, bb.ymin) ||
-      geom.segmentIntersection(a[0], a[1], b[0], b[1], bb.xmax, bb.ymin, bb.xmin, bb.ymin));
-  }
-
   function getPolylineBufferMaker2(arcs, geod, getBearing, opts) {
     var makeLeftBuffer = getPathBufferMaker2(arcs, geod, getBearing, opts);
     var geomType = opts.geometry_type;
@@ -32733,6 +32912,8 @@ ${svg}
     var colorArg = opts.colors && opts.colors.length == 1 ? opts.colors[0] : null;
     var colorScheme;
 
+    if (method == 'blacki') return [];
+
     if (colorArg == 'random') {
       if (categorical) {
         return getRandomColors(n);
@@ -32802,7 +32983,7 @@ ${svg}
   }
 
   var sequential = ['quantile', 'nice', 'equal-interval', 'hybrid', 'breaks'];
-  var all = ['non-adjacent', 'indexed', 'categorical'].concat(sequential);
+  var all = ['non-adjacent', 'indexed', 'categorical', 'blacki'].concat(sequential);
 
   function getClassifyMethod(opts, dataType) {
     var method;
@@ -32836,6 +33017,79 @@ ${svg}
     return method;
   }
 
+  function getBlackiClassifier(lyr, dataField) {
+  	var records = lyr.data.getRecords();
+    // classes are integers, dataIds can be any scalar
+    var dataToClassIndex = {};
+    var classToDataIndex = [];
+    var classCount = 0;
+
+    records.forEach(function(rec, recId) {
+      var dataIds = rec[dataField];
+      var thisClass = -1;
+      var thatClass, dataId;
+
+      if (!Array.isArray(dataIds)) return;
+
+      for (var i=0; i<dataIds.length; i++) {
+        dataId = dataIds[i];
+        thatClass = dataId in dataToClassIndex ? dataToClassIndex[dataId] : -1;
+        if (thatClass == -1) {
+          if (thisClass == -1) {
+            thisClass = classCount++;
+            classToDataIndex[thisClass] = [dataId];
+          }
+          dataToClassIndex[dataId] = thisClass;
+
+        } else {
+
+          if (thisClass == -1) {
+            thisClass = thatClass;
+          } else if (thisClass > thatClass) {
+            mergeClassIntoClass(thisClass, thatClass);
+            thisClass = thatClass;
+          } else if (thisClass < thatClass) {
+            mergeClassIntoClass(thatClass, thisClass);
+          }
+        }
+      }
+    });
+
+    var remapTable = compressClassIds();
+    var classIds = records.map(function(rec) {
+      var ids = rec[dataField];
+      if (!Array.isArray(ids) || ids.length === 0) return -1;
+      // TODO: assert that ids all belong to the same class
+      if (ids[0] in dataToClassIndex === false) {
+        error('Internal error');
+      }
+      return remapTable[dataToClassIndex[ids[0]]];
+    });
+
+    classToDataIndex = null;
+    dataToClassIndex = null;
+
+    return function(recId) {
+      return classIds[recId];
+    };
+
+    function compressClassIds() {
+      var newId = -1;
+      return classToDataIndex.map(function(d, oldId) {
+        if (d !== null) newId++;
+        return newId;
+      });
+    }
+
+    function mergeClassIntoClass(fromId, toId) {
+      classToDataIndex[fromId].forEach(function(dataId) {
+        dataToClassIndex[dataId] = toId;
+      });
+      classToDataIndex[toId] = utils.uniq(classToDataIndex[toId].concat(classToDataIndex[fromId]));
+      classToDataIndex[fromId] = null;
+    }
+  }
+
   cmd.classify = function(lyr, dataset, optsArg) {
     if (!lyr.data) {
       initDataTable(lyr);
@@ -32898,6 +33152,8 @@ ${svg}
         stop('Invalid number of classes:', opts.classes, '(expected a value greater than 1)');
       }
       numClasses = opts.classes;
+    } else if (method == 'blacki') {
+      numClasses = 999; // dummy value
     } else if (method == 'indexed' && dataField) {
       numClasses = getIndexedClassCount(records, dataField);
     } else if (opts.breaks) {
@@ -32935,6 +33191,8 @@ ${svg}
     if (fieldType === null) {
       // no valid data -- always return null value
       classifyByRecordId = function() {return nullValue;};
+    } else if (method == 'blacki') {
+      classifyByRecordId = getBlackiClassifier(lyr, dataField);
     } else if (method == 'non-adjacent') {
       classifyByRecordId = getNonAdjacentClassifier(lyr, dataset, values);
     } else if (method == 'indexed') {
@@ -37095,7 +37353,7 @@ ${svg}
     editor.done();
     if (!opts.debug) {
       buildTopology(dataset);
-      cleanProjectedLayers(dataset);
+      cleanProjectedPathLayers(dataset);
     }
   }
 
@@ -37606,15 +37864,41 @@ ${svg}
     } else {
       clipData = getClippingDataset(src, dest, opts);
     }
+    // clip data to projection limits (some projections), if content exceeds the limit
+    //
     if (clipData) {
-      // TODO: don't bother to clip content that is fully within
-      // the clipping shape. But how to tell?
-      clipLayersInPlace(dataset.layers, clipData, dataset, 'clip');
-      clipped = true;
+      clipped = clipLayersIfNeeded(dataset, clipData);
     }
     return cut || clipped;
   }
 
+  function clipLayersIfNeeded(dataset, clipData) {
+    // Avoid clipping layers that are fully enclosed within the projectable
+    // coordinate space (represented by a dataset containing a single
+    // polygon layer, @clipData). This avoids performing unnecessary intersection
+    // tests on each line segment.
+    var layers = dataset.layers.filter(function(lyr) {
+      return !layerIsFullyEnclosed(lyr, dataset, clipData);
+    });
+    if (layers.length > 0) {
+      clipLayersInPlace(layers, clipData, dataset, 'clip');
+      return true;
+    }
+    return false;
+  }
+
+  // @clipData: a dataset containing a polygon layer
+  function layerIsFullyEnclosed(lyr, dataset, clipData) {
+    // This test uses the layer's bounding box to represent the extent of the
+    // layer, and can produce false negatives.
+    var dataBounds = getLayerBounds(lyr, dataset.arcs);
+    var enclosed = false;
+    clipData.layers[0].shapes.forEach(function(shp, i) {
+      enclosed = enclosed || testBoundsInPolygon(dataBounds, shp, clipData.arcs);
+    });
+    return enclosed;
+  }
+
 
   function insertPreProjectionCuts(dataset, src, dest) {
     var antimeridian = getAntimeridian(dest.lam0 * 180 / Math.PI);
@@ -37809,7 +38093,6 @@ ${svg}
     var badArcs = 0;
     var badPoints = 0;
     var clipped = preProjectionClip(dataset, src, dest, opts);
-
     dataset.layers.forEach(function(lyr) {
       if (layerHasPoints(lyr)) {
         badPoints += projectPointLayer(lyr, proj); // v2 compatible (invalid points are removed)
@@ -37826,7 +38109,7 @@ ${svg}
     if (clipped) {
       // TODO: could more selective in cleaning clipped layers
       // (probably only needed when clipped area crosses the antimeridian or includes a pole)
-      cleanProjectedLayers(dataset);
+      cleanProjectedPathLayers(dataset);
     }
 
     if (badArcs > 0 && !opts.quiet) {
@@ -37842,7 +38125,7 @@ ${svg}
   // * Removes line intersections
   // * TODO: what if a layer contains polygons with desired overlaps? should
   //   we ignore overlaps between different features?
-  function cleanProjectedLayers(dataset) {
+  function cleanProjectedPathLayers(dataset) {
     // TODO: only clean affected polygons (cleaning all polygons can be slow)
     var polygonLayers = dataset.layers.filter(lyr => lyr.geometry_type == 'polygon');
     // clean options: force a topology update (by default, this only happens when
@@ -37910,7 +38193,7 @@ ${svg}
     __proto__: null,
     fetchCrsInfo: fetchCrsInfo,
     projectDataset: projectDataset,
-    cleanProjectedLayers: cleanProjectedLayers,
+    cleanProjectedPathLayers: cleanProjectedPathLayers,
     projectPointLayer: projectPointLayer,
     projectArcs: projectArcs,
     projectArcs2: projectArcs2
@@ -38884,12 +39167,12 @@ ${svg}
   function polylineToMidpoints(shp, arcs, opts) {
     if (!shp) return null;
     var points = shp.map(function(path) {
-      return findPathMidpoint(path, arcs);
+      return findPathMidpoint(path, arcs, false);
     });
     return points;
   }
 
-  function findPathMidpoint(path, arcs) {
+  function findPathMidpoint(path, arcs, useNearestVertex) {
     var halfLen = calcPathLen(path, arcs, false) / 2;
     var partialLen = 0;
     var p;
@@ -38906,7 +39189,11 @@ ${svg}
       var k;
       if (partialLen + segLen >= halfLen) {
         k = (halfLen - partialLen) / segLen;
-        p = [a + k * (c - a), b + k * (d - b)];
+        if (useNearestVertex) {
+          k = k < 0.5 ? 0 : 1;
+        }
+        // p = [a + k * (c - a), b + k * (d - b)];
+        p = [(1 - k) * a + k * c, (1 - k) * b + k * d];
       }
       partialLen += segLen;
     });
@@ -42786,7 +43073,7 @@ ${svg}
       name == 'point-grid' || name == 'shape' || name == 'rectangle' ||
       name == 'require' || name == 'run' || name == 'define' ||
       name == 'include' || name == 'print' || name == 'comment' || name == 'if' || name == 'elif' ||
-      name == 'else' || name == 'endif' || name == 'stop';
+      name == 'else' || name == 'endif' || name == 'stop' || name == 'add-shape';
   }
 
   async function runCommand(command, job) {
@@ -42860,7 +43147,14 @@ ${svg}
         source = findCommandSource(convertSourceName(opts.source, targets), job.catalog, opts);
       }
 
-      if (name == 'affine') {
+      if (name == 'add-shape') {
+        if (!targetDataset) {
+          targetDataset = {info: {}, layers: []};
+          targetLayers = targetDataset.layers;
+          job.catalog.addDataset(targetDataset);
+        }
+        outputLayers = cmd.addShape(targetLayers, targetDataset, opts);
+      } else if (name == 'affine') {
         cmd.affine(targetLayers, targetDataset, opts);
 
       } else if (name == 'alpha-shapes') {