@turf/isobands 7.0.0-alpha.2 → 7.0.0

package/dist/es/package.json

@@ -1 +0,0 @@
-{"type":"module"}

package/dist/js/index.js

@@ -1,232 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-const bbox_1 = tslib_1.__importDefault(require("@turf/bbox"));
-const area_1 = tslib_1.__importDefault(require("@turf/area"));
-const boolean_point_in_polygon_1 = tslib_1.__importDefault(require("@turf/boolean-point-in-polygon"));
-const explode_1 = tslib_1.__importDefault(require("@turf/explode"));
-const invariant_1 = require("@turf/invariant");
-const helpers_1 = require("@turf/helpers");
-const grid_to_matrix_1 = tslib_1.__importDefault(require("./lib/grid-to-matrix"));
-const marchingsquares_isobands_1 = tslib_1.__importDefault(require("./lib/marchingsquares-isobands"));
-/**
- * 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 (!helpers_1.isObject(options))
-        throw new Error("options is invalid");
-    const zProperty = options.zProperty || "elevation";
-    const commonProperties = options.commonProperties || {};
-    const breaksProperties = options.breaksProperties || [];
-    // Validation
-    invariant_1.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 (!helpers_1.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 = grid_to_matrix_1.default(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] && !helpers_1.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 = helpers_1.multiPolygon(contour.groupedRings, contourProperties);
-        return multiP;
-    });
-    return helpers_1.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 = marchingsquares_isobands_1.default(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_1.default(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_1.default(helpers_1.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 = helpers_1.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 = helpers_1.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_1.default(testPolygon);
-    for (let i = 0; i < points.features.length; i++) {
-        if (!boolean_point_in_polygon_1.default(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;
-}
-exports.default = isobands;

package/dist/js/lib/grid-to-matrix.d.ts

@@ -1,37 +0,0 @@
-/**
- * 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: any, options?: {
-    zProperty?: string;
-    flip?: boolean;
-    flags?: boolean;
-} | undefined): number[][];

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

@@ -1,104 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const invariant_1 = require("@turf/invariant");
-const meta_1 = require("@turf/meta");
-const helpers_1 = require("@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]
- *   ]
- */
-function gridToMatrix(grid, options) {
-    // Optional parameters
-    options = options || {};
-    if (!helpers_1.isObject(options))
-        throw new Error("options is invalid");
-    var zProperty = options.zProperty || "elevation";
-    var flip = options.flip;
-    var flags = options.flags;
-    // validation
-    invariant_1.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;
-}
-exports.default = gridToMatrix;
-/**
- * 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
-    meta_1.featureEach(points, function (point) {
-        var lat = invariant_1.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 invariant_1.getCoords(a)[0] - invariant_1.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 invariant_1.getCoords(a[0])[1] - invariant_1.getCoords(b[0])[1];
-        else
-            return invariant_1.getCoords(b[0])[1] - invariant_1.getCoords(a[0])[1];
-    });
-    return pointMatrix;
-}

package/dist/js/lib/marchingsquares-isobands.d.ts

@@ -1 +0,0 @@
-export default function isoBands(data: any, minV: any, bandwidth: any, options: any): any[];