umap-project 1.14.0a4__py3-none-any.whl → 2.0.0a0__py3-none-any.whl

umap/static/umap/vendors/csv2geojson/index.js

@@ -0,0 +1,259 @@
+'use strict';
+
+var dsv = require('d3-dsv'),
+    sexagesimal = require('@mapbox/sexagesimal');
+
+var latRegex = /(Lat)(itude)?/gi,
+    lonRegex = /(L)(on|ng)(gitude)?/i;
+
+function guessHeader(row, regexp) {
+    var name, match, score;
+    for (var f in row) {
+        match = f.match(regexp);
+        if (match && (!name || match[0].length / f.length > score)) {
+            score = match[0].length / f.length;
+            name = f;
+        }
+    }
+    return name;
+}
+
+function guessLatHeader(row) { return guessHeader(row, latRegex); }
+function guessLonHeader(row) { return guessHeader(row, lonRegex); }
+
+function isLat(f) { return !!f.match(latRegex); }
+function isLon(f) { return !!f.match(lonRegex); }
+
+function keyCount(o) {
+    return (typeof o == 'object') ? Object.keys(o).length : 0;
+}
+
+function autoDelimiter(x) {
+    var delimiters = [',', ';', '\t', '|'];
+    var results = [];
+
+    delimiters.forEach(function (delimiter) {
+        var res = dsv.dsvFormat(delimiter).parse(x);
+        if (res.length >= 1) {
+            var count = keyCount(res[0]);
+            for (var i = 0; i < res.length; i++) {
+                if (keyCount(res[i]) !== count) return;
+            }
+            results.push({
+                delimiter: delimiter,
+                arity: Object.keys(res[0]).length,
+            });
+        }
+    });
+
+    if (results.length) {
+        return results.sort(function (a, b) {
+            return b.arity - a.arity;
+        })[0].delimiter;
+    } else {
+        return null;
+    }
+}
+
+/**
+ * Silly stopgap for dsv to d3-dsv upgrade
+ *
+ * @param {Array} x dsv output
+ * @returns {Array} array without columns member
+ */
+function deleteColumns(x) {
+    delete x.columns;
+    return x;
+}
+
+function auto(x) {
+    var delimiter = autoDelimiter(x);
+    if (!delimiter) return null;
+    return deleteColumns(dsv.dsvFormat(delimiter).parse(x));
+}
+
+function csv2geojson(x, options, callback) {
+
+    if (!callback) {
+        callback = options;
+        options = {};
+    }
+
+    options.delimiter = options.delimiter || ',';
+
+    var latfield = options.latfield || '',
+        lonfield = options.lonfield || '',
+        crs = options.crs || '';
+
+    var features = [],
+        featurecollection = {type: 'FeatureCollection', features: features};
+
+    if (crs !== '') {
+        featurecollection.crs = {type: 'name', properties: {name: crs}};
+    }
+
+    if (options.delimiter === 'auto' && typeof x == 'string') {
+        options.delimiter = autoDelimiter(x);
+        if (!options.delimiter) {
+            callback({
+                type: 'Error',
+                message: 'Could not autodetect delimiter'
+            });
+            return;
+        }
+    }
+
+    var numericFields = options.numericFields ? options.numericFields.split(',') : null;
+
+    var parsed = (typeof x == 'string') ?
+        dsv.dsvFormat(options.delimiter).parse(x, function (d) {
+            if (numericFields) {
+                for (var key in d) {
+                    if (numericFields.includes(key)) {
+                        d[key] = +d[key];
+                    }
+                }
+            }
+            return d;
+        }) : x;
+
+    if (!parsed.length) {
+        callback(null, featurecollection);
+        return;
+    }
+
+    var errors = [];
+    var i;
+
+
+    if (!latfield) latfield = guessLatHeader(parsed[0]);
+    if (!lonfield) lonfield = guessLonHeader(parsed[0]);
+    var noGeometry = (!latfield || !lonfield);
+
+    if (noGeometry) {
+        for (i = 0; i < parsed.length; i++) {
+            features.push({
+                type: 'Feature',
+                properties: parsed[i],
+                geometry: null
+            });
+        }
+        callback(errors.length ? errors : null, featurecollection);
+        return;
+    }
+
+    for (i = 0; i < parsed.length; i++) {
+        if (parsed[i][lonfield] !== undefined &&
+            parsed[i][latfield] !== undefined) {
+
+            var lonk = parsed[i][lonfield],
+                latk = parsed[i][latfield],
+                lonf, latf,
+                a;
+
+            a = sexagesimal(lonk, 'EW');
+            if (a) lonk = a;
+            a = sexagesimal(latk, 'NS');
+            if (a) latk = a;
+
+            lonf = parseFloat(lonk);
+            latf = parseFloat(latk);
+
+            if (isNaN(lonf) ||
+                isNaN(latf)) {
+                errors.push({
+                    message: 'A row contained an invalid value for latitude or longitude',
+                    row: parsed[i],
+                    index: i
+                });
+            } else {
+                if (!options.includeLatLon) {
+                    delete parsed[i][lonfield];
+                    delete parsed[i][latfield];
+                }
+
+                features.push({
+                    type: 'Feature',
+                    properties: parsed[i],
+                    geometry: {
+                        type: 'Point',
+                        coordinates: [
+                            parseFloat(lonf),
+                            parseFloat(latf)
+                        ]
+                    }
+                });
+            }
+        }
+    }
+
+    callback(errors.length ? errors : null, featurecollection);
+}
+
+function toLine(gj) {
+    var features = gj.features;
+    var line = {
+        type: 'Feature',
+        geometry: {
+            type: 'LineString',
+            coordinates: []
+        }
+    };
+    for (var i = 0; i < features.length; i++) {
+        line.geometry.coordinates.push(features[i].geometry.coordinates);
+    }
+    line.properties = features.reduce(function (aggregatedProperties, newFeature) {
+        for (var key in newFeature.properties) {
+            if (!aggregatedProperties[key]) {
+                aggregatedProperties[key] = [];
+            }
+            aggregatedProperties[key].push(newFeature.properties[key]);
+        }
+        return aggregatedProperties;
+    }, {});
+    return {
+        type: 'FeatureCollection',
+        features: [line]
+    };
+}
+
+function toPolygon(gj) {
+    var features = gj.features;
+    var poly = {
+        type: 'Feature',
+        geometry: {
+            type: 'Polygon',
+            coordinates: [[]]
+        }
+    };
+    for (var i = 0; i < features.length; i++) {
+        poly.geometry.coordinates[0].push(features[i].geometry.coordinates);
+    }
+    poly.properties = features.reduce(function (aggregatedProperties, newFeature) {
+        for (var key in newFeature.properties) {
+            if (!aggregatedProperties[key]) {
+                aggregatedProperties[key] = [];
+            }
+            aggregatedProperties[key].push(newFeature.properties[key]);
+        }
+        return aggregatedProperties;
+    }, {});
+    return {
+        type: 'FeatureCollection',
+        features: [poly]
+    };
+}
+
+module.exports = {
+    isLon: isLon,
+    isLat: isLat,
+    guessLatHeader: guessLatHeader,
+    guessLonHeader: guessLonHeader,
+    csv: dsv.csvParse,
+    tsv: dsv.tsvParse,
+    dsv: dsv,
+    auto: auto,
+    csv2geojson: csv2geojson,
+    toLine: toLine,
+    toPolygon: toPolygon
+};