@turf/isobands 7.0.0-alpha.1 → 7.0.0-alpha.110

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turf/isobands",
-  "version": "7.0.0-alpha.1",
+  "version": "7.0.0-alpha.110+1411d63a7",
   "description": "turf isobands module",
   "author": "Turf Authors",
   "contributors": [
@@ -28,57 +28,62 @@
     "topography",
     "filled"
   ],
-  "main": "dist/js/index.js",
-  "module": "dist/es/index.js",
+  "type": "commonjs",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.mjs",
+  "types": "dist/cjs/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "types": "./dist/js/index.d.ts",
-      "import": "./dist/es/index.js",
-      "require": "./dist/js/index.js"
+      "import": {
+        "types": "./dist/esm/index.d.mts",
+        "default": "./dist/esm/index.mjs"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.cjs"
+      }
     }
   },
-  "types": "dist/js/index.d.ts",
   "sideEffects": false,
   "files": [
     "dist"
   ],
   "scripts": {
-    "bench": "tsx bench.js",
-    "build": "npm-run-all build:*",
-    "build:es": "tsc --outDir dist/es --module esnext --declaration false && echo '{\"type\":\"module\"}' > dist/es/package.json",
-    "build:js": "tsc",
-    "docs": "tsx ../../scripts/generate-readmes",
-    "test": "npm-run-all test:*",
-    "test:tape": "tsx test.js"
+    "bench": "tsx bench.ts",
+    "build": "tsup --config ../../tsup.config.ts",
+    "docs": "tsx ../../scripts/generate-readmes.ts",
+    "test": "npm-run-all --npm-path npm test:*",
+    "test:tape": "tsx test.ts"
   },
   "devDependencies": {
-    "@turf/envelope": "^7.0.0-alpha.1",
-    "@turf/point-grid": "^7.0.0-alpha.1",
-    "@turf/random": "^7.0.0-alpha.1",
-    "@turf/rhumb-destination": "^7.0.0-alpha.1",
-    "@turf/truncate": "^7.0.0-alpha.1",
-    "benchmark": "*",
-    "chroma-js": "*",
-    "load-json-file": "*",
-    "matrix-to-grid": "*",
-    "npm-run-all": "*",
-    "rollup": "*",
-    "tape": "*",
-    "tslint": "*",
-    "tsx": "*",
-    "typescript": "*",
-    "write-json-file": "*"
+    "@turf/envelope": "^7.0.0-alpha.110+1411d63a7",
+    "@turf/point-grid": "^7.0.0-alpha.110+1411d63a7",
+    "@turf/random": "^7.0.0-alpha.110+1411d63a7",
+    "@turf/rhumb-destination": "^7.0.0-alpha.110+1411d63a7",
+    "@turf/truncate": "^7.0.0-alpha.110+1411d63a7",
+    "@types/benchmark": "^2.1.5",
+    "@types/tape": "^4.2.32",
+    "benchmark": "^2.1.4",
+    "load-json-file": "^7.0.1",
+    "matrix-to-grid": "^4.0.0",
+    "npm-run-all": "^4.1.5",
+    "tape": "^5.7.2",
+    "tsup": "^8.0.1",
+    "tsx": "^4.6.2",
+    "typescript": "^5.2.2",
+    "write-json-file": "^5.0.0"
   },
   "dependencies": {
-    "@turf/area": "^7.0.0-alpha.1",
-    "@turf/bbox": "^7.0.0-alpha.1",
-    "@turf/boolean-point-in-polygon": "^7.0.0-alpha.1",
-    "@turf/explode": "^7.0.0-alpha.1",
-    "@turf/helpers": "^7.0.0-alpha.1",
-    "@turf/invariant": "^7.0.0-alpha.1",
-    "@turf/meta": "^7.0.0-alpha.1",
-    "tslib": "^2.3.0"
+    "@turf/area": "^7.0.0-alpha.110+1411d63a7",
+    "@turf/bbox": "^7.0.0-alpha.110+1411d63a7",
+    "@turf/boolean-point-in-polygon": "^7.0.0-alpha.110+1411d63a7",
+    "@turf/explode": "^7.0.0-alpha.110+1411d63a7",
+    "@turf/helpers": "^7.0.0-alpha.110+1411d63a7",
+    "@turf/invariant": "^7.0.0-alpha.110+1411d63a7",
+    "@turf/meta": "^7.0.0-alpha.110+1411d63a7",
+    "marchingsquares": "^1.3.3",
+    "tslib": "^2.6.2"
   },
-  "gitHead": "cf7a0c507b017ca066acffd0ce23bda5b393fb5a"
+  "gitHead": "1411d63a74c275c9216fe48e9d3cb2d48a359068"
 }

package/dist/es/index.js

@@ -1,229 +0,0 @@
-import bbox from "@turf/bbox";
-import area from "@turf/area";
-import booleanPointInPolygon from "@turf/boolean-point-in-polygon";
-import explode from "@turf/explode";
-import { collectionOf } from "@turf/invariant";
-import { polygon, multiPolygon, featureCollection, isObject, } from "@turf/helpers";
-import gridToMatrix from "./lib/grid-to-matrix.js";
-import isoBands from "./lib/marchingsquares-isobands.js";
-/**
- * Takes a square or rectangular grid {@link FeatureCollection} of {@link Point} features with z-values and an array of
- * value breaks and generates filled contour isobands.
- *
- * @name isobands
- * @param {FeatureCollection<Point>} pointGrid input points - must be square or rectangular
- * @param {Array<number>} breaks where to draw contours
- * @param {Object} [options={}] options on output
- * @param {string} [options.zProperty='elevation'] the property name in `points` from which z-values will be pulled
- * @param {Object} [options.commonProperties={}] GeoJSON properties passed to ALL isobands
- * @param {Array<Object>} [options.breaksProperties=[]] GeoJSON properties passed, in order, to the correspondent isoband (order defined by breaks)
- * @returns {FeatureCollection<MultiPolygon>} a FeatureCollection of {@link MultiPolygon} features representing isobands
- */
-function isobands(pointGrid, breaks, options) {
-    // Optional parameters
-    options = options || {};
-    if (!isObject(options))
-        throw new Error("options is invalid");
-    const zProperty = options.zProperty || "elevation";
-    const commonProperties = options.commonProperties || {};
-    const breaksProperties = options.breaksProperties || [];
-    // Validation
-    collectionOf(pointGrid, "Point", "Input must contain Points");
-    if (!breaks)
-        throw new Error("breaks is required");
-    if (!Array.isArray(breaks))
-        throw new Error("breaks is not an Array");
-    if (!isObject(commonProperties))
-        throw new Error("commonProperties is not an Object");
-    if (!Array.isArray(breaksProperties))
-        throw new Error("breaksProperties is not an Array");
-    // Isoband methods
-    const matrix = gridToMatrix(pointGrid, { zProperty: zProperty, flip: true });
-    let contours = createContourLines(matrix, breaks, zProperty);
-    contours = rescaleContours(contours, matrix, pointGrid);
-    const multipolygons = contours.map((contour, index) => {
-        if (breaksProperties[index] && !isObject(breaksProperties[index])) {
-            throw new Error("Each mappedProperty is required to be an Object");
-        }
-        // collect all properties
-        const contourProperties = Object.assign(Object.assign({}, commonProperties), breaksProperties[index]);
-        contourProperties[zProperty] = contour[zProperty];
-        const multiP = multiPolygon(contour.groupedRings, contourProperties);
-        return multiP;
-    });
-    return featureCollection(multipolygons);
-}
-/**
- * Creates the contours lines (featuresCollection of polygon features) from the 2D data grid
- *
- * Marchingsquares process the grid data as a 3D representation of a function on a 2D plane, therefore it
- * assumes the points (x-y coordinates) are one 'unit' distance. The result of the IsoBands function needs to be
- * rescaled, with turfjs, to the original area and proportions on the map
- *
- * @private
- * @param {Array<Array<number>>} matrix Grid Data
- * @param {Array<number>} breaks Breaks
- * @param {string} [property='elevation'] Property
- * @returns {Array<any>} contours
- */
-function createContourLines(matrix, breaks, property) {
-    const contours = [];
-    for (let i = 1; i < breaks.length; i++) {
-        const lowerBand = +breaks[i - 1]; // make sure the breaks value is a number
-        const upperBand = +breaks[i];
-        const isobandsCoords = isoBands(matrix, lowerBand, upperBand - lowerBand);
-        // as per GeoJson rules for creating a Polygon, make sure the first element
-        // in the array of LinearRings represents the exterior ring (i.e. biggest area),
-        // and any subsequent elements represent interior rings (i.e. smaller area);
-        // this avoids rendering issues of the MultiPolygons on the map
-        const nestedRings = orderByArea(isobandsCoords);
-        const groupedRings = groupNestedRings(nestedRings);
-        contours.push({
-            groupedRings: groupedRings,
-            [property]: lowerBand + "-" + upperBand,
-        });
-    }
-    return contours;
-}
-/**
- * Transform isobands of 2D grid to polygons for the map
- *
- * @private
- * @param {Array<any>} contours Contours
- * @param {Array<Array<number>>} matrix Grid Data
- * @param {Object} points Points by Latitude
- * @returns {Array<any>} contours
- */
-function rescaleContours(contours, matrix, points) {
-    // get dimensions (on the map) of the original grid
-    const gridBbox = bbox(points); // [ minX, minY, maxX, maxY ]
-    const originalWidth = gridBbox[2] - gridBbox[0];
-    const originalHeigth = gridBbox[3] - gridBbox[1];
-    // get origin, which is the first point of the last row on the rectangular data on the map
-    const x0 = gridBbox[0];
-    const y0 = gridBbox[1];
-    // get number of cells per side
-    const matrixWidth = matrix[0].length - 1;
-    const matrixHeight = matrix.length - 1;
-    // calculate the scaling factor between matrix and rectangular grid on the map
-    const scaleX = originalWidth / matrixWidth;
-    const scaleY = originalHeigth / matrixHeight;
-    const resize = (point) => {
-        point[0] = point[0] * scaleX + x0;
-        point[1] = point[1] * scaleY + y0;
-    };
-    // resize and shift each point/line of the isobands
-    contours.forEach(function (contour) {
-        contour.groupedRings.forEach(function (lineRingSet) {
-            lineRingSet.forEach(function (lineRing) {
-                lineRing.forEach(resize);
-            });
-        });
-    });
-    return contours;
-}
-/*  utility functions */
-/**
- * Returns an array of coordinates (of LinearRings) in descending order by area
- *
- * @private
- * @param {Array<LineString>} ringsCoords array of closed LineString
- * @returns {Array} array of the input LineString ordered by area
- */
-function orderByArea(ringsCoords) {
-    const ringsWithArea = [];
-    const areas = [];
-    ringsCoords.forEach(function (coords) {
-        // const poly = polygon([points]);
-        const ringArea = area(polygon([coords]));
-        // create an array of areas value
-        areas.push(ringArea);
-        // associate each lineRing with its area
-        ringsWithArea.push({ ring: coords, area: ringArea });
-    });
-    areas.sort(function (a, b) {
-        // bigger --> smaller
-        return b - a;
-    });
-    // create a new array of linearRings coordinates ordered by their area
-    const orderedByArea = [];
-    areas.forEach(function (area) {
-        for (let lr = 0; lr < ringsWithArea.length; lr++) {
-            if (ringsWithArea[lr].area === area) {
-                orderedByArea.push(ringsWithArea[lr].ring);
-                ringsWithArea.splice(lr, 1);
-                break;
-            }
-        }
-    });
-    return orderedByArea;
-}
-/**
- * Returns an array of arrays of coordinates, each representing
- * a set of (coordinates of) nested LinearRings,
- * i.e. the first ring contains all the others
- *
- * @private
- * @param {Array} orderedLinearRings array of coordinates (of LinearRings) in descending order by area
- * @returns {Array<Array>} Array of coordinates of nested LinearRings
- */
-function groupNestedRings(orderedLinearRings) {
-    // create a list of the (coordinates of) LinearRings
-    const lrList = orderedLinearRings.map((lr) => {
-        return { lrCoordinates: lr, grouped: false };
-    });
-    const groupedLinearRingsCoords = [];
-    while (!allGrouped(lrList)) {
-        for (let i = 0; i < lrList.length; i++) {
-            if (!lrList[i].grouped) {
-                // create new group starting with the larger not already grouped ring
-                const group = [];
-                group.push(lrList[i].lrCoordinates);
-                lrList[i].grouped = true;
-                const outerMostPoly = polygon([lrList[i].lrCoordinates]);
-                // group all the rings contained by the outermost ring
-                for (let j = i + 1; j < lrList.length; j++) {
-                    if (!lrList[j].grouped) {
-                        const lrPoly = polygon([lrList[j].lrCoordinates]);
-                        if (isInside(lrPoly, outerMostPoly)) {
-                            group.push(lrList[j].lrCoordinates);
-                            lrList[j].grouped = true;
-                        }
-                    }
-                }
-                // insert the new group
-                groupedLinearRingsCoords.push(group);
-            }
-        }
-    }
-    return groupedLinearRingsCoords;
-}
-/**
- * @private
- * @param {Polygon} testPolygon polygon of interest
- * @param {Polygon} targetPolygon polygon you want to compare with
- * @returns {boolean} true if test-Polygon is inside target-Polygon
- */
-function isInside(testPolygon, targetPolygon) {
-    const points = explode(testPolygon);
-    for (let i = 0; i < points.features.length; i++) {
-        if (!booleanPointInPolygon(points.features[i], targetPolygon)) {
-            return false;
-        }
-    }
-    return true;
-}
-/**
- * @private
- * @param {Array<Object>} list list of objects which might contain the 'group' attribute
- * @returns {boolean} true if all the objects in the list are marked as grouped
- */
-function allGrouped(list) {
-    for (let i = 0; i < list.length; i++) {
-        if (list[i].grouped === false) {
-            return false;
-        }
-    }
-    return true;
-}
-export default isobands;

package/dist/es/lib/grid-to-matrix.js

@@ -1,101 +0,0 @@
-import { getCoords, collectionOf } from "@turf/invariant";
-import { featureEach } from "@turf/meta";
-import { isObject } from "@turf/helpers";
-/**
- * Takes a {@link Point} grid and returns a correspondent matrix {Array<Array<number>>}
- * of the 'property' values
- *
- * @name gridToMatrix
- * @param {FeatureCollection<Point>} grid of points
- * @param {Object} [options={}] Optional parameters
- * @param {string} [options.zProperty='elevation'] the property name in `points` from which z-values will be pulled
- * @param {boolean} [options.flip=false] returns the matrix upside-down
- * @param {boolean} [options.flags=false] flags, adding a `matrixPosition` array field ([row, column]) to its properties,
- * the grid points with coordinates on the matrix
- * @returns {Array<Array<number>>} matrix of property values
- * @example
- *   var extent = [-70.823364, -33.553984, -70.473175, -33.302986];
- *   var cellSize = 3;
- *   var grid = turf.pointGrid(extent, cellSize);
- *   // add a random property to each point between 0 and 60
- *   for (var i = 0; i < grid.features.length; i++) {
- *     grid.features[i].properties.elevation = (Math.random() * 60);
- *   }
- *   gridToMatrix(grid);
- *   //= [
- *     [ 1, 13, 10,  9, 10, 13, 18],
- *     [34,  8,  5,  4,  5,  8, 13],
- *     [10,  5,  2,  1,  2,  5,  4],
- *     [ 0,  4, 56, 19,  1,  4,  9],
- *     [10,  5,  2,  1,  2,  5, 10],
- *     [57,  8,  5,  4,  5,  0, 57],
- *     [ 3, 13, 10,  9,  5, 13, 18],
- *     [18, 13, 10,  9, 78, 13, 18]
- *   ]
- */
-export default function gridToMatrix(grid, options) {
-    // Optional parameters
-    options = options || {};
-    if (!isObject(options))
-        throw new Error("options is invalid");
-    var zProperty = options.zProperty || "elevation";
-    var flip = options.flip;
-    var flags = options.flags;
-    // validation
-    collectionOf(grid, "Point", "input must contain Points");
-    var pointsMatrix = sortPointsByLatLng(grid, flip);
-    var matrix = [];
-    // create property matrix from sorted points
-    // looping order matters here
-    for (var r = 0; r < pointsMatrix.length; r++) {
-        var pointRow = pointsMatrix[r];
-        var row = [];
-        for (var c = 0; c < pointRow.length; c++) {
-            var point = pointRow[c];
-            // Check if zProperty exist
-            if (point.properties[zProperty])
-                row.push(point.properties[zProperty]);
-            else
-                row.push(0);
-            // add flags
-            if (flags === true)
-                point.properties.matrixPosition = [r, c];
-        }
-        matrix.push(row);
-    }
-    return matrix;
-}
-/**
- * Sorts points by latitude and longitude, creating a 2-dimensional array of points
- *
- * @private
- * @param {FeatureCollection<Point>} points GeoJSON Point features
- * @param {boolean} [flip=false] returns the matrix upside-down
- * @returns {Array<Array<Point>>} points ordered by latitude and longitude
- */
-function sortPointsByLatLng(points, flip) {
-    var pointsByLatitude = {};
-    // divide points by rows with the same latitude
-    featureEach(points, function (point) {
-        var lat = getCoords(point)[1];
-        if (!pointsByLatitude[lat])
-            pointsByLatitude[lat] = [];
-        pointsByLatitude[lat].push(point);
-    });
-    // sort points (with the same latitude) by longitude
-    var orderedRowsByLatitude = Object.keys(pointsByLatitude).map(function (lat) {
-        var row = pointsByLatitude[lat];
-        var rowOrderedByLongitude = row.sort(function (a, b) {
-            return getCoords(a)[0] - getCoords(b)[0];
-        });
-        return rowOrderedByLongitude;
-    });
-    // sort rows (of points with the same latitude) by latitude
-    var pointMatrix = orderedRowsByLatitude.sort(function (a, b) {
-        if (flip)
-            return getCoords(a[0])[1] - getCoords(b[0])[1];
-        else
-            return getCoords(b[0])[1] - getCoords(a[0])[1];
-    });
-    return pointMatrix;
-}