mapshaper 0.6.44 → 0.6.46

package/mapshaper.js

@@ -1,6 +1,6 @@
 (function () {
 
-  var VERSION = "0.6.44";
+  var VERSION = "0.6.46";
 
 
   var utils = /*#__PURE__*/Object.freeze({
@@ -1813,6 +1813,23 @@
     return [xmin, ymin, xmax, ymax];
   }
 
+
+  function findArcIdFromVertexId(i, ii) {
+    // binary search
+    // possible optimization: use interpolation to find a better partition value.
+    var lower = 0, upper = ii.length - 1;
+    var middle;
+    while (lower < upper) {
+      middle = Math.ceil((lower + upper) / 2);
+      if (i < ii[middle]) {
+        upper = middle - 1;
+      } else {
+        lower = middle;
+      }
+    }
+    return lower; // assumes dataset is not empty
+  }
+
   function deleteVertex(arcs, i) {
     var data = arcs.getVertexData();
     var nn = data.nn;
@@ -1882,12 +1899,68 @@
     arcs.updateVertexData(nn, xx2, yy2, zz2);
   }
 
+  function countFilteredVertices(zz, zlimit) {
+    var count = 0;
+    for (var i=0, n = zz.length; i<n; i++) {
+      if (zz[i] >= zlimit) count++;
+    }
+    return count;
+  }
+
+  function filterVertexData(o, zlimit) {
+    if (!o.zz) error('Expected simplification data');
+    var xx = o.xx,
+        yy = o.yy,
+        zz = o.zz,
+        len2 = countFilteredVertices(zz, zlimit),
+        arcCount = o.nn.length,
+        xx2 = new Float64Array(len2),
+        yy2 = new Float64Array(len2),
+        zz2 = new Float64Array(len2),
+        nn2 = new Int32Array(arcCount),
+        i = 0, i2 = 0,
+        n, n2;
+
+    for (var arcId=0; arcId < arcCount; arcId++) {
+      n2 = 0;
+      n = o.nn[arcId];
+      for (var end = i+n; i < end; i++) {
+        if (zz[i] >= zlimit) {
+          xx2[i2] = xx[i];
+          yy2[i2] = yy[i];
+          zz2[i2] = zz[i];
+          i2++;
+          n2++;
+        }
+      }
+      if (n2 == 1) {
+        error("Collapsed arc");
+        // This should not happen (endpoints should be z == Infinity)
+        // Could handle like this, instead of throwing an error:
+        // n2 = 0;
+        // xx2.pop();
+        // yy2.pop();
+        // zz2.pop();
+      }
+      nn2[arcId] = n2;
+    }
+    return {
+      xx: xx2,
+      yy: yy2,
+      zz: zz2,
+      nn: nn2
+    };
+  }
+
   var ArcUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
     absArcId: absArcId,
     calcArcBounds: calcArcBounds,
+    findArcIdFromVertexId: findArcIdFromVertexId,
     deleteVertex: deleteVertex,
-    insertVertex: insertVertex
+    insertVertex: insertVertex,
+    countFilteredVertices: countFilteredVertices,
+    filterVertexData: filterVertexData
   });
 
   var WGS84 = {
@@ -3350,7 +3423,7 @@
     var item;
     for (var i=0; i<arr.length; i++) {
       item = arr[i];
-      if (item instanceof Array) {
+      if (Array.isArray(item)) {
         forEachArcId(item, cb);
       } else if (utils.isInteger(item)) {
         var val = cb(item);
@@ -5359,17 +5432,6 @@
       initZData(zz || null);
     };
 
-    // Give access to raw data arrays...
-    this.getVertexData = function() {
-      return {
-        xx: _xx,
-        yy: _yy,
-        zz: _zz,
-        bb: _bb,
-        nn: _nn,
-        ii: _ii
-      };
-    };
 
     this.getCopy = function() {
       var copy = new ArcCollection(new Int32Array(_nn), new Float64Array(_xx),
@@ -5381,55 +5443,28 @@
       return copy;
     };
 
+
+    // Give access to raw data arrays...
+    this.getVertexData = getVertexData;
+
+    function getVertexData() {
+      return {
+        xx: _xx,
+        yy: _yy,
+        zz: _zz,
+        bb: _bb,
+        nn: _nn,
+        ii: _ii
+      };
+    }
+
     function getFilteredPointCount() {
-      var zz = _zz, z = _zlimit;
-      if (!zz || !z) return this.getPointCount();
-      var count = 0;
-      for (var i=0, n = zz.length; i<n; i++) {
-        if (zz[i] >= z) count++;
-      }
-      return count;
+      if (!_zz || !_zlimit) return this.getPointCount();
+      return countFilteredVertices(_zz, _zlimit);
     }
 
     function getFilteredVertexData() {
-      var len2 = getFilteredPointCount();
-      var arcCount = _nn.length;
-      var xx2 = new Float64Array(len2),
-          yy2 = new Float64Array(len2),
-          zz2 = new Float64Array(len2),
-          nn2 = new Int32Array(arcCount),
-          i=0, i2 = 0,
-          n, n2;
-
-      for (var arcId=0; arcId < arcCount; arcId++) {
-        n2 = 0;
-        n = _nn[arcId];
-        for (var end = i+n; i < end; i++) {
-          if (_zz[i] >= _zlimit) {
-            xx2[i2] = _xx[i];
-            yy2[i2] = _yy[i];
-            zz2[i2] = _zz[i];
-            i2++;
-            n2++;
-          }
-        }
-        if (n2 == 1) {
-          error("Collapsed arc");
-          // This should not happen (endpoints should be z == Infinity)
-          // Could handle like this, instead of throwing an error:
-          // n2 = 0;
-          // xx2.pop();
-          // yy2.pop();
-          // zz2.pop();
-        }
-        nn2[arcId] = n2;
-      }
-      return {
-        xx: xx2,
-        yy: yy2,
-        zz: zz2,
-        nn: nn2
-      };
+      return filterVertexData(getVertexData(), _zlimit);
     }
 
     this.getFilteredCopy = function() {
@@ -6936,6 +6971,15 @@
     utils.defaults(destInfo, srcInfo);
   }
 
+  function copyDatasetInfo(info) {
+    // not a deep copy... objects like info.crs are read-only, so copy-by-reference
+    // should be ok
+    var info2 = Object.assign({}, info);
+    if (Array.isArray(info.input_files)) {
+      info2.input_files = info.input_files.concat();
+    }
+    return info2;
+  }
 
   function splitApartLayers(dataset, layers) {
     var datasets = [];
@@ -7102,6 +7146,7 @@
     __proto__: null,
     splitDataset: splitDataset,
     mergeDatasetInfo: mergeDatasetInfo,
+    copyDatasetInfo: copyDatasetInfo,
     splitApartLayers: splitApartLayers,
     copyDataset: copyDataset,
     copyDatasetForExport: copyDatasetForExport,
@@ -10828,28 +10873,59 @@
   }
 
   // gui: (optional) gui instance
-  //
+  // opts examples:
+  //    exporting from command line: { compact: true, file: 'tmp.msx', final: true }
+  //    exporting from gui export menu: {compact: true, format: 'msx'}
+  //    saving gui temp snapshot: {compact: false}
   async function exportDatasetsToPack(datasets, opts) {
     var obj = {
       version: 1,
       created: (new Date).toISOString(),
-      datasets: await Promise.all(datasets.map(exportDataset))
+      datasets: await Promise.all(datasets.map(dataset => exportDataset(dataset, opts)))
     };
-    if (opts.compact) {
-      await applyCompression(obj);
-    }
     return obj;
   }
 
-  async function applyCompression(obj, opts) {
-    var promises = [];
-    obj.datasets.forEach(d => {
-      if (d.arcs) promises.push(compressArcs(d.arcs, opts));
+  async function exportDataset(dataset, opts) {
+    var arcs = dataset.arcs;
+    var arcData = null;
+    if (arcs) {
+      arcData = arcs.getVertexData();
+      arcData.zlimit = arcs.getRetainedInterval(); // TODO: add this to getVertexData()
+      arcData = await exportArcData(arcData, opts);
+    }
+    return {
+      arcs: arcData,
+      info: dataset.info ? exportInfo(dataset.info) : null,
+      layers: await Promise.all((dataset.layers || []).map(exportLayer))
+    };
+  }
+
+  // compress unpacked + uncompressed snapshot data in-place
+  async function compressSnapshotForExport(obj) {
+    var promises = obj.datasets.map(d => {
+      compressDatasetForExport(d);
     });
     await Promise.all(promises);
+    return;
+  }
+
+  async function compressDatasetForExport(obj) {
+    if (!obj.arcs) return;
+    var arcData = importArcData(obj.arcs); // convert buffers to typed arrays
+    obj.arcs = await exportArcData(arcData, {compact: true}); // re-export to compressed buffers
   }
 
-  async function compressArcs(obj, opts) {
+  function flattenArcs(arcData) {
+    if (arcData.zz && arcData.zlimit) {
+      // replace unfiltered arc data with flattened arc data
+      arcData = filterVertexData(arcData, arcData.zlimit);
+      delete arcData.zz;
+    }
+    return arcData;
+  }
+
+  async function gzipArcData(obj, opts) {
     var gzipOpts = Object.assign({level: 1, consume: false}, opts);
     var promises = [gzipAsync(obj.nn, gzipOpts), gzipAsync(obj.xx, gzipOpts), gzipAsync(obj.yy, gzipOpts)];
     if (obj.zz) promises.push(gzipAsync(obj.zz, gzipOpts));
@@ -10860,27 +10936,36 @@
     if (obj.zz) obj.zz = results.shift();
   }
 
-  async function exportDataset(dataset, opts) {
+  function importArcData(obj) {
     return {
-      arcs: dataset.arcs ? exportArcs(dataset.arcs) : null,
-      info: dataset.info ? exportInfo(dataset.info) : null,
-      layers: await Promise.all((dataset.layers || []).map(exportLayer))
+      nn: new Uint32Array(obj.nn.buffer, 0, obj.nn.length / 4),
+      xx: new Float64Array(obj.xx.buffer, 0, obj.xx.length / 8),
+      yy: new Float64Array(obj.yy.buffer, 0, obj.yy.length / 8),
+      zz: obj.zz ? new Float64Array(obj.zz.buffer, 0, obj.zz.length / 8) : null,
+      zlimit: obj.zlimit || 0
     };
   }
 
-  function typedArrayToBuffer(arr) {
-    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
-  }
-
-  function exportArcs(arcs) {
-    var data = arcs.getVertexData();
-    return {
+  async function exportArcData(data, opts) {
+    // TODO: consider removing arcs that are not referenced by any layer
+    if (opts.compact && data.zz) {
+      data = flattenArcs(data); // bake in any simplification
+    }
+    var output = {
       nn: typedArrayToBuffer(data.nn),
       xx: typedArrayToBuffer(data.xx),
       yy: typedArrayToBuffer(data.yy),
       zz: data.zz ? typedArrayToBuffer(data.zz) : null,
-      zlimit: arcs.getRetainedInterval()
+      zlimit: data.zlimit || 0
     };
+    if (opts.compact && data.zz) {
+      await gzipArcData(output);
+    }
+    return output;
+  }
+
+  function typedArrayToBuffer(arr) {
+    return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
   }
 
   async function exportLayer(lyr) {
@@ -10914,8 +10999,8 @@
     exportPackedDatasets: exportPackedDatasets,
     pack: pack,
     exportDatasetsToPack: exportDatasetsToPack,
-    applyCompression: applyCompression,
     exportDataset: exportDataset,
+    compressSnapshotForExport: compressSnapshotForExport,
     exportInfo: exportInfo
   });
 
@@ -15424,6 +15509,17 @@
 
   // Keep track of whether positive or negative integer ids are 'used' or not.
 
+
+  function SimpleIdTestIndex(n) {
+    var index = new Uint8Array(n);
+    this.setId = function(id) {
+      index[id] = 1;
+    };
+    this.hasId = function(id) {
+      return index[id] === 1;
+    };
+  }
+
   function IdTestIndex(n) {
     var index = new Uint8Array(n);
     var setList = [];
@@ -15686,15 +15782,30 @@
     getHoleDivider: getHoleDivider
   });
 
-  // Convert an array of intersections into an ArcCollection (for display)
-  //
-
   function getIntersectionPoints(intersections) {
     return intersections.map(function(obj) {
           return [obj.x, obj.y];
         });
   }
 
+  function getIntersectionLayer(intersections, lyr, arcs) {
+    // return {geometry_type: 'point', shapes: [getIntersectionPoints(XX)]};
+    var ii = arcs.getVertexData().ii;
+    var index = new SimpleIdTestIndex(arcs.size());
+    forEachArcId(lyr.shapes, arcId => {
+      index.setId(absArcId(arcId));
+    });
+    var points = [];
+    intersections.forEach(obj => {
+      var arc1 = findArcIdFromVertexId(obj.a[0], ii);
+      var arc2 = findArcIdFromVertexId(obj.b[0], ii);
+      if (index.hasId(arc1) && index.hasId(arc2)) {
+        points.push([obj.x, obj.y]);
+      }
+    });
+    return {geometry_type: 'point', shapes: [points]};
+  }
+
   // Identify intersecting segments in an ArcCollection
   //
   // To find all intersections:
@@ -15942,6 +16053,7 @@
   var SegmentIntersection = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getIntersectionPoints: getIntersectionPoints,
+    getIntersectionLayer: getIntersectionLayer,
     findSegmentIntersections: findSegmentIntersections,
     sortIntersections: sortIntersections,
     dedupIntersections: dedupIntersections,
@@ -15952,6 +16064,67 @@
     formatIntersectingSegment: formatIntersectingSegment
   });
 
+  // Remap any references to duplicate arcs in paths to use the same arcs
+  // Remove any unused arcs from the dataset's ArcCollection.
+  // Return a NodeCollection
+  function cleanArcReferences(dataset) {
+    var nodes = new NodeCollection(dataset.arcs);
+    var map = findDuplicateArcs(nodes);
+    var dropCount;
+    if (map) {
+      replaceIndexedArcIds(dataset, map);
+    }
+    dropCount = deleteUnusedArcs(dataset);
+    if (dropCount > 0) {
+      // rebuild nodes if arcs have changed
+      nodes = new NodeCollection(dataset.arcs);
+    }
+    return nodes;
+  }
+
+  function deleteUnusedArcs(dataset) {
+    var test = getArcPresenceTest2(dataset.layers, dataset.arcs);
+    var count1 = dataset.arcs.size();
+    var map = dataset.arcs.deleteArcs(test); // condenses arcs
+    var count2 = dataset.arcs.size();
+    var deleteCount = count1 - count2;
+    if (deleteCount > 0) {
+      replaceIndexedArcIds(dataset, map);
+    }
+    return deleteCount;
+  }
+
+  // @map an Object mapping old to new ids
+  function replaceIndexedArcIds(dataset, map) {
+    var remapPath = function(ids) {
+      var arcId, absId, id2;
+      for (var i=0; i<ids.length; i++) {
+        arcId = ids[i];
+        absId = absArcId(arcId);
+        id2 = map[absId];
+        ids[i] = arcId == absId ? id2 : ~id2;
+      }
+      return ids;
+    };
+    dataset.layers.forEach(function(lyr) {
+      if (layerHasPaths(lyr)) {
+        editShapes(lyr.shapes, remapPath);
+      }
+    });
+  }
+
+  function findDuplicateArcs(nodes) {
+    var map = new Int32Array(nodes.arcs.size()),
+        count = 0,
+        i2;
+    for (var i=0, n=nodes.arcs.size(); i<n; i++) {
+      i2 = nodes.findDuplicateArc(i);
+      map[i] = i2;
+      if (i != i2) count++;
+    }
+    return count > 0 ? map : null;
+  }
+
   // Functions for dividing polygons and polygons at points where arc-segments intersect
 
   // TODO:
@@ -16041,68 +16214,6 @@
   }
 
 
-  // Remap any references to duplicate arcs in paths to use the same arcs
-  // Remove any unused arcs from the dataset's ArcCollection.
-  // Return a NodeCollection
-  function cleanArcReferences(dataset) {
-    var nodes = new NodeCollection(dataset.arcs);
-    var map = findDuplicateArcs(nodes);
-    var dropCount;
-    if (map) {
-      replaceIndexedArcIds(dataset, map);
-    }
-    dropCount = deleteUnusedArcs(dataset);
-    if (dropCount > 0) {
-      // rebuild nodes if arcs have changed
-      nodes = new NodeCollection(dataset.arcs);
-    }
-    return nodes;
-  }
-
-
-  // @map an Object mapping old to new ids
-  function replaceIndexedArcIds(dataset, map) {
-    var remapPath = function(ids) {
-      var arcId, absId, id2;
-      for (var i=0; i<ids.length; i++) {
-        arcId = ids[i];
-        absId = absArcId(arcId);
-        id2 = map[absId];
-        ids[i] = arcId == absId ? id2 : ~id2;
-      }
-      return ids;
-    };
-    dataset.layers.forEach(function(lyr) {
-      if (layerHasPaths(lyr)) {
-        editShapes(lyr.shapes, remapPath);
-      }
-    });
-  }
-
-  function findDuplicateArcs(nodes) {
-    var map = new Int32Array(nodes.arcs.size()),
-        count = 0,
-        i2;
-    for (var i=0, n=nodes.arcs.size(); i<n; i++) {
-      i2 = nodes.findDuplicateArc(i);
-      map[i] = i2;
-      if (i != i2) count++;
-    }
-    return count > 0 ? map : null;
-  }
-
-  function deleteUnusedArcs(dataset) {
-    var test = getArcPresenceTest2(dataset.layers, dataset.arcs);
-    var count1 = dataset.arcs.size();
-    var map = dataset.arcs.deleteArcs(test); // condenses arcs
-    var count2 = dataset.arcs.size();
-    var deleteCount = count1 - count2;
-    if (deleteCount > 0) {
-      replaceIndexedArcIds(dataset, map);
-    }
-    return deleteCount;
-  }
-
   // Return a function for updating a path (array of arc ids)
   // @map array generated by insertCutPoints()
   // @arcCount number of arcs in divided collection (kludge)
@@ -17458,8 +17569,9 @@
           exporter = GeoJSON.exporters[lyr.geometry_type],
           geom = shape ? exporter(shape, dataset.arcs, opts) : null,
           obj = null;
+
       if (asFeatures) {
-        obj = GeoJSON.toFeature(geom, properties ? properties[i] : null);
+        obj = composeFeature(geom, properties ? properties[i] : null, opts);
         if (ids) {
           obj.id = ids[i];
         }
@@ -17483,6 +17595,20 @@
     }, []);
   }
 
+  function composeFeature(geom, properties, opts) {
+    var feat = GeoJSON.toFeature(geom, properties);
+    if (Array.isArray(opts.hoist) && properties) {
+      // don't modify properties of source feature
+      feat.properties = Object.assign({}, properties);
+      opts.hoist.forEach(field => {
+        if (properties.hasOwnProperty(field)) {
+          feat[field] = properties[field];
+          delete feat.properties[field];
+        }
+      });
+    }
+    return feat;
+  }
 
   function getRFC7946Warnings(dataset) {
     var P = getDatasetCRS(dataset);
@@ -21576,6 +21702,14 @@ ${svg}
       }
       return memo.concat(exportFileContent(dataset, opts));
     }, []);
+
+    if (opts.bbox_index) {
+      // If rounding or quantization are applied during export, bounds may
+      // change somewhat... consider adding a bounds property to each layer during
+      // export when appropriate.
+      files.push(createIndexFile(datasets));
+    }
+
     // need unique names for multiple output files
     assignUniqueFileNames(files);
 
@@ -21633,15 +21767,7 @@ ${svg}
     }
 
     validateLayerData(dataset.layers);
-
     files = exporter(dataset, opts).concat(files);
-    // If rounding or quantization are applied during export, bounds may
-    // change somewhat... consider adding a bounds property to each layer during
-    // export when appropriate.
-    if (opts.bbox_index) {
-      files.push(createIndexFile(dataset));
-    }
-
     validateFileNames(files);
     return files;
   }
@@ -21662,13 +21788,16 @@ ${svg}
   // Generate json file with bounding boxes and names of each export layer
   // TODO: consider making this a command, or at least make format settable
   //
-  function createIndexFile(dataset) {
-    var index = dataset.layers.map(function(lyr) {
-      var bounds = getLayerBounds(lyr, dataset.arcs);
-      return {
-        bbox: bounds.toArray(),
-        name: lyr.name
-      };
+  function createIndexFile(datasets) {
+    var index = [];
+    datasets.forEach(function(dataset) {
+      dataset.layers.forEach(function(lyr) {
+        var bounds = getLayerBounds(lyr, dataset.arcs);
+        index.push({
+          bbox: bounds.toArray(),
+          name: lyr.name
+        });
+      });
     });
 
     return {
@@ -23391,7 +23520,7 @@ ${svg}
       .option('string-fields', stringFieldsOpt)
       .option('field-types', fieldTypesOpt)
       .option('name', {
-        describe: 'Rename the imported layer(s)'
+        describe: 'rename the imported layer(s)'
       })
       .option('geometry-type', {
         // undocumented; GeoJSON import rejects all but one kind of geometry
@@ -23560,6 +23689,10 @@ ${svg}
         describe: '[GeoJSON/JSON] output newline-delimited features or records',
         type: 'flag'
       })
+      .option('hoist', {
+        describe: '[GeoJSON] move properties to the root level of each Feature',
+        type: 'strings'
+      })
       .option('width', {
         describe: '[SVG/TopoJSON] pixel width of output (SVG default is 800)',
         type: 'number'
@@ -33318,7 +33451,7 @@ ${svg}
     if (n != values.length) {
       stop('Mismatch in number of categories and number of values');
     }
-    return values;
+    return parseValues(values); // convert numerical strings to numbers
   }
 
   function getIndexes(n) {
@@ -33486,7 +33619,7 @@ ${svg}
     if (opts.index_field) {
       dataField = opts.index_field;
       fieldType = getColumnType(opts.field, records);
-   } else if (opts.field) {
+    } else if (opts.field) {
       dataField = opts.field;
       fieldType = getColumnType(opts.field, records);
     }
@@ -33510,7 +33643,6 @@ ${svg}
       stop('Missing a data field to classify');
     }
 
-
     // get the number of classes and the number of values
     //
     // expand categories if value is '*'
@@ -33519,6 +33651,9 @@ ${svg}
       if ((!opts.categories || opts.categories.includes('*')) && dataField) {
         opts.categories = getUniqFieldValues(records, dataField);
       }
+      if (opts.categories && fieldType == 'number') {
+        opts.categories = opts.categories.map(str => +str);
+      }
     }
 
     if (opts.classes) {
@@ -34663,34 +34798,48 @@ ${svg}
   }
 
   function getFeatureEditor(lyr, dataset) {
-    var changed = false;
     var api = {};
     // need to copy attribute to avoid circular references if geojson is assigned
     // to a data property.
     var copy = copyLayer(lyr);
     var features = exportLayerAsGeoJSON(copy, dataset, {}, true);
+    var features2 = [];
 
     api.get = function(i) {
+      if (i > 0) features[i-1] = null; // garbage-collect old features
       return features[i];
     };
 
     api.set = function(feat, i) {
-      changed = true;
+      var arr;
+
       if (utils.isString(feat)) {
         feat = JSON.parse(feat);
       }
-      features[i] = GeoJSON.toFeature(feat); // TODO: validate
+
+      if (!feat) return;
+
+      if (feat.type == 'GeometryCollection') {
+        arr = feat.geometries.map(geom => GeoJSON.toFeature(geom));
+      } else if (feat.type == 'FeatureCollection') {
+        arr = feat.features;
+      } else {
+        feat = GeoJSON.toFeature(feat);
+      }
+
+      if (arr) {
+        features2 = features2.concat(arr);
+      } else {
+        features2.push(feat);
+      }
     };
 
     api.done = function() {
-      if (!changed) return; // read-only expression
-      // TODO: validate number of features, etc.
+      if (features2.length === 0) return; // read-only expression
       var geojson = {
         type: 'FeatureCollection',
-        features: features
+        features: features2
       };
-
-      // console.log(JSON.stringify(geojson, null, 2))
       return importGeoJSON(geojson);
     };
     return api;
@@ -40453,9 +40602,8 @@ ${svg}
   cmd.polygonGrid = function(targetLayers, targetDataset, opts) {
     requireProjectedDataset(targetDataset);
     var params = getGridParams(targetLayers, targetDataset, opts);
-    var gridDataset = makeGridDataset(params);
-
-    gridDataset.info = targetDataset.info; // copy CRS to grid dataset // TODO: improve
+    var gridDataset = makeGridDataset(params); // grid is a new dataset
+    gridDataset.info = copyDatasetInfo(targetDataset.info);
     setOutputLayerName(gridDataset.layers[0], null, 'grid', opts);
     if (opts.debug) gridDataset.layers.push(cmd.pointGrid2(targetLayers, targetDataset, opts));
     return gridDataset;