mapshaper 0.7.49 → 0.7.51

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mapshaper",
-  "version": "0.7.49",
+  "version": "0.7.51",
   "description": "A tool for editing geospatial data for mapping and GIS.",
   "keywords": [
     "shapefile",
@@ -71,7 +71,7 @@
     "idb-keyval": "^6.2.0",
     "jpeg-js": "^0.4.4",
     "kdbush": "^3.0.0",
-    "mproj": "0.1.5",
+    "mproj": "0.1.6",
     "msgpackr": "^1.11.12",
     "open": "^11.0.0",
     "pngjs": "^7.0.0",
@@ -101,7 +101,7 @@
     ],
     "check-leaks": true,
     "parallel": true,
-    "jobs": 4
+    "jobs": 6
   },
   "bin": {
     "mapshaper": "bin/mapshaper",

package/www/mapshaper-gui.js

@@ -6876,31 +6876,37 @@
   // instead.
 
 
+  // Undo is on unless it has been turned off. Undoing is what a user expects by
+  // default; the History menu's checkbox exists so that sessions working with
+  // data too large to store restore payloads for can opt out.
+  var APP_UNDO_DEFAULT = true;
+
   // Returns true if the manifest, URL query, gui-installed checker, or
   // localStorage indicates that app-level undo should be active.
   function appUndoIsEnabled(gui) {
     var opt = gui && gui.options && (gui.options.undoCommands || gui.options.appUndo);
     var query = getUndoQueryValue();
+    if (query == 'off') return false;
     if (opt === true || query == 'on' || query == 'commands') return true;
     if (gui && gui.appUndoIsEnabled) return gui.appUndoIsEnabled();
     return appUndoSettingIsOn();
   }
 
-  // True when the undo URL flag forces app undo on regardless of UI settings.
-  // Mirrors the toggle-disable behavior in HistoryMenu.
+  // True when the undo URL flag pins app undo on or off regardless of UI
+  // settings. Mirrors the toggle-disable behavior in HistoryMenu.
   function appUndoForcedByUrl() {
     var query = getUndoQueryValue();
-    return query == 'on' || query == 'commands';
+    return query == 'on' || query == 'commands' || query == 'off';
   }
 
-  // Read the persisted localStorage opt-in. Returns false in non-browser
-  // environments or when storage is blocked.
+  // Read the persisted setting. Only an explicit opt-out turns undo off, so a
+  // first-time session (and one where storage is unreadable) gets the default.
   function appUndoSettingIsOn() {
     try {
-      return !!(typeof window != 'undefined' && window.localStorage &&
-        window.localStorage.getItem('mapshaper.undo') == 'on');
+      if (typeof window == 'undefined' || !window.localStorage) return APP_UNDO_DEFAULT;
+      return window.localStorage.getItem('mapshaper.undo') != 'off';
     } catch(e) {
-      return false;
+      return APP_UNDO_DEFAULT;
     }
   }
 
@@ -7398,14 +7404,20 @@
       }
     }
 
-    function turnOff() {
-      var target;
-      if (catalog) catalog.reset(); // re-enable clickable catalog
+    // Draw and select what was imported. Called when import mode ends, and by
+    // importQueuedFiles() if something else has already ended it.
+    function finishImport() {
       if (importCount > 0) {
         onImportComplete();
         importTotal += importCount;
         importCount = 0;
       }
+    }
+
+    function turnOff() {
+      var target;
+      if (catalog) catalog.reset(); // re-enable clickable catalog
+      finishImport();
       gui.clearProgressMessage();
       initialImport = false; // unset 'quick view' mode, if on
       clearQueuedFiles();
@@ -7432,8 +7444,13 @@
         gui.alert(e.message, 'Import error');
       }
       if (gui.getMode() == 'import') {
-        // Mode could also be 'alert' if an error is thrown and handled
-        gui.clearMode();
+        gui.clearMode(); // leaving import mode finishes the import
+      } else {
+        // A popup shown while files were loading (an alert about one file's
+        // metadata, say) takes the app out of import mode, so leaving it is no
+        // longer what finishes the import. Without this, the files that did load
+        // would sit in the catalog undrawn.
+        finishImport();
       }
       if (undoTransaction && imported) {
         addUndoTransactionToHistory(gui, undoTransaction, {
@@ -8056,6 +8073,15 @@
         });
       }
 
+      // A .aux.xml sidecar is named after the whole raster file
+      // (world.tif.aux.xml), so it joins that file's group rather than one of its
+      // own. Returns null if the raster it names was not loaded with it.
+      function auxSourceGroup(d) {
+        var sourceName = internal.getAuxSourceFilename(d.name).toLowerCase();
+        var source = data.find(f => f.name.toLowerCase() == sourceName);
+        return source ? key(fileBase(source), fileType(source)) : null;
+      }
+
       data.forEach(d => {
         var basename = fileBase(d);
         var type = fileType(d);
@@ -8067,6 +8093,8 @@
         } else if (type == 'dbf') {
           d.filename = d.name;
           d.group = key(basename, 'dbf');
+        } else if (type == 'aux' && auxSourceGroup(d)) {
+          d.group = auxSourceGroup(d);
         } else if ((type == 'png' || type == 'jpeg') || isRasterImagePart(d.name) && hasRasterImage(basename)) {
           d.group = key(basename, type == 'png' || type == 'jpeg' ? type : getRasterImageGroupType(data, basename));
           if (type == 'png' || type == 'jpeg') d.filename = d.name;
@@ -10630,6 +10658,8 @@
     var unsupportedMsg = "Exporting is not supported in this browser";
     var menu = gui.container.findChild('.export-options').on('click', GUI.handleDirectEvent(gui.clearMode));
     var layersArr = [];
+    var menuFormats = null; // formats the format menu was built with
+    var formatPickedByUser = false;
     var toggleBtn = null; // checkbox <input> for toggling layer selection
     var exportBtn = gui.container.findChild('.export-btn').addClass('disabled');
     var ofileName = gui.container.findChild('#ofile-name');
@@ -10698,6 +10728,7 @@
 
     function turnOn() {
       layersArr = initLayerMenu();
+      formatPickedByUser = false;
       // initZipOption();
       initFormatMenu();
       updateExportCheckboxes();
@@ -10879,6 +10910,7 @@
     }
 
     function updateToggleBtn() {
+      refreshFormatMenu(); // the layer selection decides which formats apply
       updateExportCheckboxes(); // checkbox visibility is affected by number of export layers
       if (!toggleBtn) return;
       var state = getSelectionState();
@@ -10901,19 +10933,44 @@
     }
 
     function getDefaultExportFormat() {
+      var layers = getExportFormatLayers();
       var active = model.getActiveLayer();
       var dataset = active.dataset;
       var inputFmt = dataset.info && dataset.info.input_formats &&
           dataset.info.input_formats[0];
-      if (active.layer && internal.layerHasRaster(active.layer)) return 'svg';
+      // Rasters and nothing else can only go to GeoTIFF, the one format that
+      // takes their pixels.
+      if (layers.length > 0 && layers.every(hasRaster)) return 'geotiff';
+      // SVG is the default for a selection that mixes rasters with vector layers,
+      // being the only format that accepts both.
+      if (layers.some(hasRaster)) return 'svg';
       return getExportFormats().includes(inputFmt) ? inputFmt : 'geojson';
     }
 
     function getExportFormats() {
-      return ['shapefile', 'json', 'geojson', 'dsv', 'topojson', 'flatgeobuf', 'geopackage', 'geoparquet', 'kml', 'svg', internal.PACKAGE_EXT];
+      var formats = ['shapefile', 'json', 'geojson', 'dsv', 'topojson', 'flatgeobuf', 'geopackage', 'geoparquet', 'kml', 'svg', internal.PACKAGE_EXT];
+      // GeoTIFF is the one format here that only accepts raster layers, so it is
+      // offered only when there is a raster to export.
+      if (getExportFormatLayers().some(hasRaster)) formats.push('geotiff');
+      return formats;
+    }
+
+    // The layers the format menu describes: the ones checked for export, falling
+    // back to the active layer when the menu is not up yet or nothing is checked.
+    function getExportFormatLayers() {
+      var selected = layersArr.length ? getSelectedLayerEntries() : [];
+      var active = model.getActiveLayer();
+      if (selected.length > 0) {
+        return selected.map(function(o) { return o.layer; });
+      }
+      return active && active.layer ? [active.layer] : [];
     }
 
-    function initFormatMenu() {
+    function hasRaster(lyr) {
+      return internal.layerHasRaster(lyr);
+    }
+
+    function initFormatMenu(preferredFmt) {
       var formats = getExportFormats();
       var items = formats.map(function(fmt) {
         return utils$1.format('<td><label><input type="radio" name="format" value="%s"' +
@@ -10925,13 +10982,39 @@
       }
       table += '</table>';
       menu.findChild('.export-formats').html(table);
-      menu.findChild('.export-formats input[value="' + getDefaultExportFormat() + '"]').node().checked = true;
+      menuFormats = formats;
+      setSelectedFormat(formats.includes(preferredFmt) ? preferredFmt :
+        getDefaultExportFormat());
       // update save-as settings when value changes
       menu.findChildren('input[type="radio"]').forEach(el => {
-        el.on('change', updateExportCheckboxes);
+        el.on('change', onFormatChange);
       });
     }
 
+    function onFormatChange() {
+      // A format the user picked is theirs to keep, however the layer selection
+      // changes afterwards.
+      formatPickedByUser = true;
+      updateExportCheckboxes();
+    }
+
+    function setSelectedFormat(fmt) {
+      var el = menu.findChild('.export-formats input[value="' + fmt + '"]');
+      if (el) el.node().checked = true;
+    }
+
+    // Which formats apply depends on what is checked for export, so unchecking
+    // the vector layers of a mixed session both offers GeoTIFF and makes it the
+    // default -- unless the user has already chosen a format.
+    function refreshFormatMenu() {
+      var formats = getExportFormats();
+      if (formats.join(',') != (menuFormats || []).join(',')) {
+        initFormatMenu(formatPickedByUser ? getSelectedFormat() : null);
+      } else if (!formatPickedByUser) {
+        setSelectedFormat(getDefaultExportFormat());
+      }
+    }
+
 
     // function getInputFormats() {
     //   return model.getDatasets().reduce(function(memo, d) {
@@ -12073,6 +12156,7 @@
   }
 
   function isAppUndoEnabled() {
+    if (getUndoQueryValue() == 'off') return false;
     return appUndoForcedByUrl() || appUndoSettingIsOn();
   }
 
@@ -20962,6 +21046,31 @@
 
   utils$1.inherit(MapExtent, EventDispatcher);
 
+  // Rules for drawing a raster that is being displayed larger than its data.
+  // Kept free of browser and mapshaper dependencies so they can be tested
+  // directly.
+
+  // Screen pixels per raster pixel at which a magnified raster is drawn as
+  // squares instead of being smoothed. Below this there is little detail to lose
+  // and smoothing looks better; above it, the smoothing is what a user sees
+  // instead of the data.
+  var MIN_CRISP_MAGNIFICATION = 2;
+
+  // True if a preview image holds every raster pixel in view, and so is showing
+  // the data itself rather than a scaled-down rendering of it. Only such an
+  // image is worth drawing as squares: magnifying a coarser preview would show
+  // crisp squares that are not pixels of the raster.
+  function previewHasSourcePixels(width, height, sourceWidth, sourceHeight) {
+    if (!(sourceWidth > 0) || !(sourceHeight > 0)) return false;
+    return width >= sourceWidth && height >= sourceHeight;
+  }
+
+  // sourcePixels: from previewHasSourcePixels()
+  // magnification: screen pixels per pixel of the preview image
+  function rasterPreviewIsSmoothed(sourcePixels, magnification) {
+    return !sourcePixels || !(magnification >= MIN_CRISP_MAGNIFICATION);
+  }
+
   var MAX_VIEWPORT_PREVIEW_PIXELS = 6e6;
   var cache$1 = new WeakMap();
   var requestId$1 = 0;
@@ -20988,6 +21097,7 @@
       stats = getCachedRasterScalingStats(params, timing);
       timing.renderStart = getTimer$1();
       preview = internal.renderRasterViewportPreview(params.grid, params.recipe, params.bbox, params.width, params.height, stats);
+      if (preview) preview.sourcePixels = params.sourcePixels;
       timing.renderMs = getTimer$1() - timing.renderStart;
       logRasterPreviewTiming(params, timing);
       current = cache$1.get(layer);
@@ -21039,6 +21149,7 @@
     return {
       key: key,
       needed: needed,
+      sourcePixels: previewHasSourcePixels(width, height, crop.width, crop.height),
       raster: raster,
       grid: grid,
       recipe: recipe,
@@ -21197,6 +21308,7 @@
       }
       timing.renderStart = getTimer();
       preview = internal.renderRasterPreview(grid, params.recipe, grid.width, grid.height, params.stats);
+      preview.sourcePixels = params.sourcePixels;
       applyCoverageMask(preview, grid.coverage);
       timing.renderMs = getTimer() - timing.renderStart;
       logRasterReprojectionTiming(params, timing);
@@ -21220,12 +21332,13 @@
     var viewBbox = ext && ext.getBounds().toArray();
     var bbox = rasterBbox && viewBbox && internal.intersectBboxes(rasterBbox, viewBbox);
     var size = bbox && getPreviewSize(ext, sourceGrid);
-    var recipe, stats;
+    var recipe, stats, sourcePixels;
     if (!sourceCRS || !displayCRS || !sourceGrid || !sourceGrid.samples || !bbox || !size) return null;
     recipe = internal.getRasterViewRecipe(sourceGrid, raster.view && raster.view.recipe);
     stats = internal.getRasterViewScalingStats(raster, recipe);
+    sourcePixels = outputHasSourcePixels(sourceGrid, bbox, sourceCRS, displayCRS, size);
     return {
-      key: getRasterReprojectedPreviewKey(layer, bbox, size, sourceCRS, displayCRS, recipe),
+      key: getRasterReprojectedPreviewKey(layer, bbox, size, sourceCRS, displayCRS, recipe, sourcePixels),
       grid: sourceGrid,
       sourceCRS: sourceCRS,
       displayCRS: displayCRS,
@@ -21234,11 +21347,49 @@
       height: size.height,
       recipe: recipe,
       stats: stats,
-      sampleMethod: getRasterReprojectionSampleMethod(),
+      sourcePixels: sourcePixels,
+      sampleMethod: getRasterReprojectionSampleMethod(sourcePixels),
       meshInterval: 32
     };
   }
 
+  // True if the reprojected grid has room for every source pixel in view, so that
+  // sampling it without interpolation gives back the raster's own pixels. This is
+  // the zoomed-in case: reprojecting a raster to fewer pixels than it has needs
+  // interpolation to avoid dropping data.
+  function outputHasSourcePixels(grid, bbox, sourceCRS, displayCRS, size) {
+    var sourceSize = getSourcePixelsInView(grid, bbox, sourceCRS, displayCRS);
+    return !!sourceSize && previewHasSourcePixels(
+      size.width, size.height, sourceSize.width, sourceSize.height);
+  }
+
+  // Estimates how many of the raster's pixels a view covers, by taking the part
+  // of the source grid that the view maps back onto. Returns null if the view
+  // does not map back (e.g. it includes coordinates outside the projection).
+  function getSourcePixelsInView(grid, bbox, sourceCRS, displayCRS) {
+    var transform = internal.getProjTransform2(displayCRS, sourceCRS);
+    var xx = [bbox[0], (bbox[0] + bbox[2]) / 2, bbox[2]];
+    var yy = [bbox[1], (bbox[1] + bbox[3]) / 2, bbox[3]];
+    var xmin = Infinity, ymin = Infinity, xmax = -Infinity, ymax = -Infinity;
+    var p;
+    if (!transform) return null;
+    for (var i = 0; i < xx.length; i++) {
+      for (var j = 0; j < yy.length; j++) {
+        p = transform(xx[i], yy[j]);
+        if (!p || !isFinite(p[0]) || !isFinite(p[1])) continue;
+        if (p[0] < xmin) xmin = p[0];
+        if (p[0] > xmax) xmax = p[0];
+        if (p[1] < ymin) ymin = p[1];
+        if (p[1] > ymax) ymax = p[1];
+      }
+    }
+    if (!(xmax > xmin) || !(ymax > ymin)) return null;
+    return {
+      width: (xmax - xmin) / (grid.bbox[2] - grid.bbox[0]) * grid.width,
+      height: (ymax - ymin) / (grid.bbox[3] - grid.bbox[1]) * grid.height
+    };
+  }
+
   function getPreviewSize(ext, grid) {
     var pixelRatio = GUI.getPixelRatio();
     var t = ext.getTransform(pixelRatio);
@@ -21253,10 +21404,11 @@
     return {width: width, height: height};
   }
 
-  function getRasterReprojectedPreviewKey(layer, bbox, size, sourceCRS, displayCRS, recipe) {
+  function getRasterReprojectedPreviewKey(layer, bbox, size, sourceCRS, displayCRS, recipe, sourcePixels) {
     return [
       size.width,
       size.height,
+      sourcePixels,
       bbox.join(','),
       internal.crsToProj4(sourceCRS),
       internal.crsToProj4(displayCRS),
@@ -21264,7 +21416,7 @@
       recipe.scaling,
       recipe.scaleRange && recipe.scaleRange.join(','),
       recipe.percentileRange && recipe.percentileRange.join(','),
-      getRasterReprojectionSampleMethod(),
+      getRasterReprojectionSampleMethod(sourcePixels),
       layer.raster && layer.raster.grid && layer.raster.grid.samples && layer.raster.grid.samples.length
     ].join('|');
   }
@@ -21292,10 +21444,13 @@
     }
   }
 
-  function getRasterReprojectionSampleMethod() {
+  function getRasterReprojectionSampleMethod(sourcePixels) {
     var vars = GUI.getUrlVars();
     var val = vars['raster-bilinear'] ?? vars.raster_bilinear;
-    return val === false || val == '0' ? 'nearest' : 'bilinear';
+    if (val === false || val == '0') return 'nearest';
+    // Interpolating between pixels when there is room for all of them would blur
+    // the data away for nothing.
+    return sourcePixels ? 'nearest' : 'bilinear';
   }
 
   function logRasterReprojectionTiming(params, timing) {
@@ -21584,7 +21739,7 @@
       var raster = layer.raster;
       var options = opts || {};
       var preview = null;
-      var bbox;
+      var bbox, grid, sourcePixels;
       if (layer.gui && layer.gui.dynamic_crs) {
         preview = getCachedRasterReprojectedPreview(layer, _ext);
         if (!preview) {
@@ -21595,7 +21750,7 @@
         }
         bbox = preview.bbox;
         if (!preview.pixels || !bbox) return;
-        drawRasterPreview(preview, bbox);
+        drawRasterPreview(preview, bbox, preview.sourcePixels);
         if (options.action != 'nav' && options.onViewportPreviewReady) {
           scheduleRasterReprojectedPreview(layer, _ext, options.onViewportPreviewReady);
         }
@@ -21603,15 +21758,21 @@
       }
       preview = options.action == 'nav' ? null : getCachedRasterViewportPreview(layer, _ext);
       bbox = preview && preview.bbox;
+      sourcePixels = preview && preview.sourcePixels;
       if (!preview) {
+        // The whole-raster preview made at import time, which is scaled down if
+        // the raster is large.
         preview = raster && internal.getRasterPreview(raster);
         bbox = raster && internal.getRasterBBox(raster);
+        grid = raster && internal.getRasterGrid(raster);
+        sourcePixels = !!(preview && grid) && previewHasSourcePixels(
+          preview.width, preview.height, grid.width, grid.height);
         if (options.action != 'nav' && options.onViewportPreviewReady) {
           scheduleRasterViewportPreview(layer, _ext, options.onViewportPreviewReady);
         }
       }
       if (!preview || !preview.pixels || !bbox) return;
-      drawRasterPreview(preview, bbox);
+      drawRasterPreview(preview, bbox, sourcePixels);
     };
 
     /*
@@ -21813,12 +21974,16 @@
       }
     }
 
-    function drawRasterPreview(preview, bbox) {
+    // sourcePixels: true if one pixel of the preview is one pixel of the raster,
+    // so that drawing it as squares shows the data rather than an artifact of
+    // whatever it was scaled down to.
+    function drawRasterPreview(preview, bbox, sourcePixels) {
       var img = getRasterCanvas(preview);
       var t = _ext.getTransform(GUI.getPixelRatio());
       var p1 = t.transform(bbox[0], bbox[3]);
       var p2 = t.transform(bbox[2], bbox[1]);
-      _ctx.imageSmoothingEnabled = true;
+      var magnification = Math.abs(p2[0] - p1[0]) / img.width / GUI.getPixelRatio();
+      _ctx.imageSmoothingEnabled = rasterPreviewIsSmoothed(sourcePixels, magnification);
       _ctx.drawImage(img, p1[0], p1[1], p2[0] - p1[0], p2[1] - p1[1]);
     }
 
@@ -25327,6 +25492,7 @@ GUI and setting the size and crop of SVG output.</p><div><input type="text" clas
     return {
       layerCount: dataset.layers ? dataset.layers.length : 0,
       arcCount: dataset.arcs ? dataset.arcs.size() : 0,
+      crs_string: dataset.info && dataset.info.crs_string || null,
       layers: (dataset.layers || []).map(function(lyr) {
         return {
           name: getLayerName(lyr),