StackGenVis: Alignment of Data, Algorithms, and Models for Stacking Ensemble Learning Using Performance Metrics
https://doi.org/10.1109/TVCG.2020.3030352
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
733 lines
24 KiB
733 lines
24 KiB
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
/**
|
|
* @module helpers
|
|
*/
|
|
/**
|
|
* Earth Radius used with the Harvesine formula and approximates using a spherical (non-ellipsoid) Earth.
|
|
*
|
|
* @memberof helpers
|
|
* @type {number}
|
|
*/
|
|
exports.earthRadius = 6371008.8;
|
|
/**
|
|
* Unit of measurement factors using a spherical (non-ellipsoid) earth radius.
|
|
*
|
|
* @memberof helpers
|
|
* @type {Object}
|
|
*/
|
|
exports.factors = {
|
|
centimeters: exports.earthRadius * 100,
|
|
centimetres: exports.earthRadius * 100,
|
|
degrees: exports.earthRadius / 111325,
|
|
feet: exports.earthRadius * 3.28084,
|
|
inches: exports.earthRadius * 39.370,
|
|
kilometers: exports.earthRadius / 1000,
|
|
kilometres: exports.earthRadius / 1000,
|
|
meters: exports.earthRadius,
|
|
metres: exports.earthRadius,
|
|
miles: exports.earthRadius / 1609.344,
|
|
millimeters: exports.earthRadius * 1000,
|
|
millimetres: exports.earthRadius * 1000,
|
|
nauticalmiles: exports.earthRadius / 1852,
|
|
radians: 1,
|
|
yards: exports.earthRadius / 1.0936,
|
|
};
|
|
/**
|
|
* Units of measurement factors based on 1 meter.
|
|
*
|
|
* @memberof helpers
|
|
* @type {Object}
|
|
*/
|
|
exports.unitsFactors = {
|
|
centimeters: 100,
|
|
centimetres: 100,
|
|
degrees: 1 / 111325,
|
|
feet: 3.28084,
|
|
inches: 39.370,
|
|
kilometers: 1 / 1000,
|
|
kilometres: 1 / 1000,
|
|
meters: 1,
|
|
metres: 1,
|
|
miles: 1 / 1609.344,
|
|
millimeters: 1000,
|
|
millimetres: 1000,
|
|
nauticalmiles: 1 / 1852,
|
|
radians: 1 / exports.earthRadius,
|
|
yards: 1 / 1.0936,
|
|
};
|
|
/**
|
|
* Area of measurement factors based on 1 square meter.
|
|
*
|
|
* @memberof helpers
|
|
* @type {Object}
|
|
*/
|
|
exports.areaFactors = {
|
|
acres: 0.000247105,
|
|
centimeters: 10000,
|
|
centimetres: 10000,
|
|
feet: 10.763910417,
|
|
inches: 1550.003100006,
|
|
kilometers: 0.000001,
|
|
kilometres: 0.000001,
|
|
meters: 1,
|
|
metres: 1,
|
|
miles: 3.86e-7,
|
|
millimeters: 1000000,
|
|
millimetres: 1000000,
|
|
yards: 1.195990046,
|
|
};
|
|
/**
|
|
* Wraps a GeoJSON {@link Geometry} in a GeoJSON {@link Feature}.
|
|
*
|
|
* @name feature
|
|
* @param {Geometry} geometry input geometry
|
|
* @param {Object} [properties={}] an Object of key-value pairs to add as properties
|
|
* @param {Object} [options={}] Optional Parameters
|
|
* @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
|
|
* @param {string|number} [options.id] Identifier associated with the Feature
|
|
* @returns {Feature} a GeoJSON Feature
|
|
* @example
|
|
* var geometry = {
|
|
* "type": "Point",
|
|
* "coordinates": [110, 50]
|
|
* };
|
|
*
|
|
* var feature = turf.feature(geometry);
|
|
*
|
|
* //=feature
|
|
*/
|
|
function feature(geom, properties, options) {
|
|
if (options === void 0) { options = {}; }
|
|
var feat = { type: "Feature" };
|
|
if (options.id === 0 || options.id) {
|
|
feat.id = options.id;
|
|
}
|
|
if (options.bbox) {
|
|
feat.bbox = options.bbox;
|
|
}
|
|
feat.properties = properties || {};
|
|
feat.geometry = geom;
|
|
return feat;
|
|
}
|
|
exports.feature = feature;
|
|
/**
|
|
* Creates a GeoJSON {@link Geometry} from a Geometry string type & coordinates.
|
|
* For GeometryCollection type use `helpers.geometryCollection`
|
|
*
|
|
* @name geometry
|
|
* @param {string} type Geometry Type
|
|
* @param {Array<any>} coordinates Coordinates
|
|
* @param {Object} [options={}] Optional Parameters
|
|
* @returns {Geometry} a GeoJSON Geometry
|
|
* @example
|
|
* var type = "Point";
|
|
* var coordinates = [110, 50];
|
|
* var geometry = turf.geometry(type, coordinates);
|
|
* // => geometry
|
|
*/
|
|
function geometry(type, coordinates, options) {
|
|
if (options === void 0) { options = {}; }
|
|
switch (type) {
|
|
case "Point": return point(coordinates).geometry;
|
|
case "LineString": return lineString(coordinates).geometry;
|
|
case "Polygon": return polygon(coordinates).geometry;
|
|
case "MultiPoint": return multiPoint(coordinates).geometry;
|
|
case "MultiLineString": return multiLineString(coordinates).geometry;
|
|
case "MultiPolygon": return multiPolygon(coordinates).geometry;
|
|
default: throw new Error(type + " is invalid");
|
|
}
|
|
}
|
|
exports.geometry = geometry;
|
|
/**
|
|
* Creates a {@link Point} {@link Feature} from a Position.
|
|
*
|
|
* @name point
|
|
* @param {Array<number>} coordinates longitude, latitude position (each in decimal degrees)
|
|
* @param {Object} [properties={}] an Object of key-value pairs to add as properties
|
|
* @param {Object} [options={}] Optional Parameters
|
|
* @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
|
|
* @param {string|number} [options.id] Identifier associated with the Feature
|
|
* @returns {Feature<Point>} a Point feature
|
|
* @example
|
|
* var point = turf.point([-75.343, 39.984]);
|
|
*
|
|
* //=point
|
|
*/
|
|
function point(coordinates, properties, options) {
|
|
if (options === void 0) { options = {}; }
|
|
var geom = {
|
|
type: "Point",
|
|
coordinates: coordinates,
|
|
};
|
|
return feature(geom, properties, options);
|
|
}
|
|
exports.point = point;
|
|
/**
|
|
* Creates a {@link Point} {@link FeatureCollection} from an Array of Point coordinates.
|
|
*
|
|
* @name points
|
|
* @param {Array<Array<number>>} coordinates an array of Points
|
|
* @param {Object} [properties={}] Translate these properties to each Feature
|
|
* @param {Object} [options={}] Optional Parameters
|
|
* @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north]
|
|
* associated with the FeatureCollection
|
|
* @param {string|number} [options.id] Identifier associated with the FeatureCollection
|
|
* @returns {FeatureCollection<Point>} Point Feature
|
|
* @example
|
|
* var points = turf.points([
|
|
* [-75, 39],
|
|
* [-80, 45],
|
|
* [-78, 50]
|
|
* ]);
|
|
*
|
|
* //=points
|
|
*/
|
|
function points(coordinates, properties, options) {
|
|
if (options === void 0) { options = {}; }
|
|
return featureCollection(coordinates.map(function (coords) {
|
|
return point(coords, properties);
|
|
}), options);
|
|
}
|
|
exports.points = points;
|
|
/**
|
|
* Creates a {@link Polygon} {@link Feature} from an Array of LinearRings.
|
|
*
|
|
* @name polygon
|
|
* @param {Array<Array<Array<number>>>} coordinates an array of LinearRings
|
|
* @param {Object} [properties={}] an Object of key-value pairs to add as properties
|
|
* @param {Object} [options={}] Optional Parameters
|
|
* @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
|
|
* @param {string|number} [options.id] Identifier associated with the Feature
|
|
* @returns {Feature<Polygon>} Polygon Feature
|
|
* @example
|
|
* var polygon = turf.polygon([[[-5, 52], [-4, 56], [-2, 51], [-7, 54], [-5, 52]]], { name: 'poly1' });
|
|
*
|
|
* //=polygon
|
|
*/
|
|
function polygon(coordinates, properties, options) {
|
|
if (options === void 0) { options = {}; }
|
|
for (var _i = 0, coordinates_1 = coordinates; _i < coordinates_1.length; _i++) {
|
|
var ring = coordinates_1[_i];
|
|
if (ring.length < 4) {
|
|
throw new Error("Each LinearRing of a Polygon must have 4 or more Positions.");
|
|
}
|
|
for (var j = 0; j < ring[ring.length - 1].length; j++) {
|
|
// Check if first point of Polygon contains two numbers
|
|
if (ring[ring.length - 1][j] !== ring[0][j]) {
|
|
throw new Error("First and last Position are not equivalent.");
|
|
}
|
|
}
|
|
}
|
|
var geom = {
|
|
type: "Polygon",
|
|
coordinates: coordinates,
|
|
};
|
|
return feature(geom, properties, options);
|
|
}
|
|
exports.polygon = polygon;
|
|
/**
|
|
* Creates a {@link Polygon} {@link FeatureCollection} from an Array of Polygon coordinates.
|
|
*
|
|
* @name polygons
|
|
* @param {Array<Array<Array<Array<number>>>>} coordinates an array of Polygon coordinates
|
|
* @param {Object} [properties={}] an Object of key-value pairs to add as properties
|
|
* @param {Object} [options={}] Optional Parameters
|
|
* @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
|
|
* @param {string|number} [options.id] Identifier associated with the FeatureCollection
|
|
* @returns {FeatureCollection<Polygon>} Polygon FeatureCollection
|
|
* @example
|
|
* var polygons = turf.polygons([
|
|
* [[[-5, 52], [-4, 56], [-2, 51], [-7, 54], [-5, 52]]],
|
|
* [[[-15, 42], [-14, 46], [-12, 41], [-17, 44], [-15, 42]]],
|
|
* ]);
|
|
*
|
|
* //=polygons
|
|
*/
|
|
function polygons(coordinates, properties, options) {
|
|
if (options === void 0) { options = {}; }
|
|
return featureCollection(coordinates.map(function (coords) {
|
|
return polygon(coords, properties);
|
|
}), options);
|
|
}
|
|
exports.polygons = polygons;
|
|
/**
|
|
* Creates a {@link LineString} {@link Feature} from an Array of Positions.
|
|
*
|
|
* @name lineString
|
|
* @param {Array<Array<number>>} coordinates an array of Positions
|
|
* @param {Object} [properties={}] an Object of key-value pairs to add as properties
|
|
* @param {Object} [options={}] Optional Parameters
|
|
* @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
|
|
* @param {string|number} [options.id] Identifier associated with the Feature
|
|
* @returns {Feature<LineString>} LineString Feature
|
|
* @example
|
|
* var linestring1 = turf.lineString([[-24, 63], [-23, 60], [-25, 65], [-20, 69]], {name: 'line 1'});
|
|
* var linestring2 = turf.lineString([[-14, 43], [-13, 40], [-15, 45], [-10, 49]], {name: 'line 2'});
|
|
*
|
|
* //=linestring1
|
|
* //=linestring2
|
|
*/
|
|
function lineString(coordinates, properties, options) {
|
|
if (options === void 0) { options = {}; }
|
|
if (coordinates.length < 2) {
|
|
throw new Error("coordinates must be an array of two or more positions");
|
|
}
|
|
var geom = {
|
|
type: "LineString",
|
|
coordinates: coordinates,
|
|
};
|
|
return feature(geom, properties, options);
|
|
}
|
|
exports.lineString = lineString;
|
|
/**
|
|
* Creates a {@link LineString} {@link FeatureCollection} from an Array of LineString coordinates.
|
|
*
|
|
* @name lineStrings
|
|
* @param {Array<Array<Array<number>>>} coordinates an array of LinearRings
|
|
* @param {Object} [properties={}] an Object of key-value pairs to add as properties
|
|
* @param {Object} [options={}] Optional Parameters
|
|
* @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north]
|
|
* associated with the FeatureCollection
|
|
* @param {string|number} [options.id] Identifier associated with the FeatureCollection
|
|
* @returns {FeatureCollection<LineString>} LineString FeatureCollection
|
|
* @example
|
|
* var linestrings = turf.lineStrings([
|
|
* [[-24, 63], [-23, 60], [-25, 65], [-20, 69]],
|
|
* [[-14, 43], [-13, 40], [-15, 45], [-10, 49]]
|
|
* ]);
|
|
*
|
|
* //=linestrings
|
|
*/
|
|
function lineStrings(coordinates, properties, options) {
|
|
if (options === void 0) { options = {}; }
|
|
return featureCollection(coordinates.map(function (coords) {
|
|
return lineString(coords, properties);
|
|
}), options);
|
|
}
|
|
exports.lineStrings = lineStrings;
|
|
/**
|
|
* Takes one or more {@link Feature|Features} and creates a {@link FeatureCollection}.
|
|
*
|
|
* @name featureCollection
|
|
* @param {Feature[]} features input features
|
|
* @param {Object} [options={}] Optional Parameters
|
|
* @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
|
|
* @param {string|number} [options.id] Identifier associated with the Feature
|
|
* @returns {FeatureCollection} FeatureCollection of Features
|
|
* @example
|
|
* var locationA = turf.point([-75.343, 39.984], {name: 'Location A'});
|
|
* var locationB = turf.point([-75.833, 39.284], {name: 'Location B'});
|
|
* var locationC = turf.point([-75.534, 39.123], {name: 'Location C'});
|
|
*
|
|
* var collection = turf.featureCollection([
|
|
* locationA,
|
|
* locationB,
|
|
* locationC
|
|
* ]);
|
|
*
|
|
* //=collection
|
|
*/
|
|
function featureCollection(features, options) {
|
|
if (options === void 0) { options = {}; }
|
|
var fc = { type: "FeatureCollection" };
|
|
if (options.id) {
|
|
fc.id = options.id;
|
|
}
|
|
if (options.bbox) {
|
|
fc.bbox = options.bbox;
|
|
}
|
|
fc.features = features;
|
|
return fc;
|
|
}
|
|
exports.featureCollection = featureCollection;
|
|
/**
|
|
* Creates a {@link Feature<MultiLineString>} based on a
|
|
* coordinate array. Properties can be added optionally.
|
|
*
|
|
* @name multiLineString
|
|
* @param {Array<Array<Array<number>>>} coordinates an array of LineStrings
|
|
* @param {Object} [properties={}] an Object of key-value pairs to add as properties
|
|
* @param {Object} [options={}] Optional Parameters
|
|
* @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
|
|
* @param {string|number} [options.id] Identifier associated with the Feature
|
|
* @returns {Feature<MultiLineString>} a MultiLineString feature
|
|
* @throws {Error} if no coordinates are passed
|
|
* @example
|
|
* var multiLine = turf.multiLineString([[[0,0],[10,10]]]);
|
|
*
|
|
* //=multiLine
|
|
*/
|
|
function multiLineString(coordinates, properties, options) {
|
|
if (options === void 0) { options = {}; }
|
|
var geom = {
|
|
type: "MultiLineString",
|
|
coordinates: coordinates,
|
|
};
|
|
return feature(geom, properties, options);
|
|
}
|
|
exports.multiLineString = multiLineString;
|
|
/**
|
|
* Creates a {@link Feature<MultiPoint>} based on a
|
|
* coordinate array. Properties can be added optionally.
|
|
*
|
|
* @name multiPoint
|
|
* @param {Array<Array<number>>} coordinates an array of Positions
|
|
* @param {Object} [properties={}] an Object of key-value pairs to add as properties
|
|
* @param {Object} [options={}] Optional Parameters
|
|
* @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
|
|
* @param {string|number} [options.id] Identifier associated with the Feature
|
|
* @returns {Feature<MultiPoint>} a MultiPoint feature
|
|
* @throws {Error} if no coordinates are passed
|
|
* @example
|
|
* var multiPt = turf.multiPoint([[0,0],[10,10]]);
|
|
*
|
|
* //=multiPt
|
|
*/
|
|
function multiPoint(coordinates, properties, options) {
|
|
if (options === void 0) { options = {}; }
|
|
var geom = {
|
|
type: "MultiPoint",
|
|
coordinates: coordinates,
|
|
};
|
|
return feature(geom, properties, options);
|
|
}
|
|
exports.multiPoint = multiPoint;
|
|
/**
|
|
* Creates a {@link Feature<MultiPolygon>} based on a
|
|
* coordinate array. Properties can be added optionally.
|
|
*
|
|
* @name multiPolygon
|
|
* @param {Array<Array<Array<Array<number>>>>} coordinates an array of Polygons
|
|
* @param {Object} [properties={}] an Object of key-value pairs to add as properties
|
|
* @param {Object} [options={}] Optional Parameters
|
|
* @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
|
|
* @param {string|number} [options.id] Identifier associated with the Feature
|
|
* @returns {Feature<MultiPolygon>} a multipolygon feature
|
|
* @throws {Error} if no coordinates are passed
|
|
* @example
|
|
* var multiPoly = turf.multiPolygon([[[[0,0],[0,10],[10,10],[10,0],[0,0]]]]);
|
|
*
|
|
* //=multiPoly
|
|
*
|
|
*/
|
|
function multiPolygon(coordinates, properties, options) {
|
|
if (options === void 0) { options = {}; }
|
|
var geom = {
|
|
type: "MultiPolygon",
|
|
coordinates: coordinates,
|
|
};
|
|
return feature(geom, properties, options);
|
|
}
|
|
exports.multiPolygon = multiPolygon;
|
|
/**
|
|
* Creates a {@link Feature<GeometryCollection>} based on a
|
|
* coordinate array. Properties can be added optionally.
|
|
*
|
|
* @name geometryCollection
|
|
* @param {Array<Geometry>} geometries an array of GeoJSON Geometries
|
|
* @param {Object} [properties={}] an Object of key-value pairs to add as properties
|
|
* @param {Object} [options={}] Optional Parameters
|
|
* @param {Array<number>} [options.bbox] Bounding Box Array [west, south, east, north] associated with the Feature
|
|
* @param {string|number} [options.id] Identifier associated with the Feature
|
|
* @returns {Feature<GeometryCollection>} a GeoJSON GeometryCollection Feature
|
|
* @example
|
|
* var pt = turf.geometry("Point", [100, 0]);
|
|
* var line = turf.geometry("LineString", [[101, 0], [102, 1]]);
|
|
* var collection = turf.geometryCollection([pt, line]);
|
|
*
|
|
* // => collection
|
|
*/
|
|
function geometryCollection(geometries, properties, options) {
|
|
if (options === void 0) { options = {}; }
|
|
var geom = {
|
|
type: "GeometryCollection",
|
|
geometries: geometries,
|
|
};
|
|
return feature(geom, properties, options);
|
|
}
|
|
exports.geometryCollection = geometryCollection;
|
|
/**
|
|
* Round number to precision
|
|
*
|
|
* @param {number} num Number
|
|
* @param {number} [precision=0] Precision
|
|
* @returns {number} rounded number
|
|
* @example
|
|
* turf.round(120.4321)
|
|
* //=120
|
|
*
|
|
* turf.round(120.4321, 2)
|
|
* //=120.43
|
|
*/
|
|
function round(num, precision) {
|
|
if (precision === void 0) { precision = 0; }
|
|
if (precision && !(precision >= 0)) {
|
|
throw new Error("precision must be a positive number");
|
|
}
|
|
var multiplier = Math.pow(10, precision || 0);
|
|
return Math.round(num * multiplier) / multiplier;
|
|
}
|
|
exports.round = round;
|
|
/**
|
|
* Convert a distance measurement (assuming a spherical Earth) from radians to a more friendly unit.
|
|
* Valid units: miles, nauticalmiles, inches, yards, meters, metres, kilometers, centimeters, feet
|
|
*
|
|
* @name radiansToLength
|
|
* @param {number} radians in radians across the sphere
|
|
* @param {string} [units="kilometers"] can be degrees, radians, miles, or kilometers inches, yards, metres,
|
|
* meters, kilometres, kilometers.
|
|
* @returns {number} distance
|
|
*/
|
|
function radiansToLength(radians, units) {
|
|
if (units === void 0) { units = "kilometers"; }
|
|
var factor = exports.factors[units];
|
|
if (!factor) {
|
|
throw new Error(units + " units is invalid");
|
|
}
|
|
return radians * factor;
|
|
}
|
|
exports.radiansToLength = radiansToLength;
|
|
/**
|
|
* Convert a distance measurement (assuming a spherical Earth) from a real-world unit into radians
|
|
* Valid units: miles, nauticalmiles, inches, yards, meters, metres, kilometers, centimeters, feet
|
|
*
|
|
* @name lengthToRadians
|
|
* @param {number} distance in real units
|
|
* @param {string} [units="kilometers"] can be degrees, radians, miles, or kilometers inches, yards, metres,
|
|
* meters, kilometres, kilometers.
|
|
* @returns {number} radians
|
|
*/
|
|
function lengthToRadians(distance, units) {
|
|
if (units === void 0) { units = "kilometers"; }
|
|
var factor = exports.factors[units];
|
|
if (!factor) {
|
|
throw new Error(units + " units is invalid");
|
|
}
|
|
return distance / factor;
|
|
}
|
|
exports.lengthToRadians = lengthToRadians;
|
|
/**
|
|
* Convert a distance measurement (assuming a spherical Earth) from a real-world unit into degrees
|
|
* Valid units: miles, nauticalmiles, inches, yards, meters, metres, centimeters, kilometres, feet
|
|
*
|
|
* @name lengthToDegrees
|
|
* @param {number} distance in real units
|
|
* @param {string} [units="kilometers"] can be degrees, radians, miles, or kilometers inches, yards, metres,
|
|
* meters, kilometres, kilometers.
|
|
* @returns {number} degrees
|
|
*/
|
|
function lengthToDegrees(distance, units) {
|
|
return radiansToDegrees(lengthToRadians(distance, units));
|
|
}
|
|
exports.lengthToDegrees = lengthToDegrees;
|
|
/**
|
|
* Converts any bearing angle from the north line direction (positive clockwise)
|
|
* and returns an angle between 0-360 degrees (positive clockwise), 0 being the north line
|
|
*
|
|
* @name bearingToAzimuth
|
|
* @param {number} bearing angle, between -180 and +180 degrees
|
|
* @returns {number} angle between 0 and 360 degrees
|
|
*/
|
|
function bearingToAzimuth(bearing) {
|
|
var angle = bearing % 360;
|
|
if (angle < 0) {
|
|
angle += 360;
|
|
}
|
|
return angle;
|
|
}
|
|
exports.bearingToAzimuth = bearingToAzimuth;
|
|
/**
|
|
* Converts an angle in radians to degrees
|
|
*
|
|
* @name radiansToDegrees
|
|
* @param {number} radians angle in radians
|
|
* @returns {number} degrees between 0 and 360 degrees
|
|
*/
|
|
function radiansToDegrees(radians) {
|
|
var degrees = radians % (2 * Math.PI);
|
|
return degrees * 180 / Math.PI;
|
|
}
|
|
exports.radiansToDegrees = radiansToDegrees;
|
|
/**
|
|
* Converts an angle in degrees to radians
|
|
*
|
|
* @name degreesToRadians
|
|
* @param {number} degrees angle between 0 and 360 degrees
|
|
* @returns {number} angle in radians
|
|
*/
|
|
function degreesToRadians(degrees) {
|
|
var radians = degrees % 360;
|
|
return radians * Math.PI / 180;
|
|
}
|
|
exports.degreesToRadians = degreesToRadians;
|
|
/**
|
|
* Converts a length to the requested unit.
|
|
* Valid units: miles, nauticalmiles, inches, yards, meters, metres, kilometers, centimeters, feet
|
|
*
|
|
* @param {number} length to be converted
|
|
* @param {Units} [originalUnit="kilometers"] of the length
|
|
* @param {Units} [finalUnit="kilometers"] returned unit
|
|
* @returns {number} the converted length
|
|
*/
|
|
function convertLength(length, originalUnit, finalUnit) {
|
|
if (originalUnit === void 0) { originalUnit = "kilometers"; }
|
|
if (finalUnit === void 0) { finalUnit = "kilometers"; }
|
|
if (!(length >= 0)) {
|
|
throw new Error("length must be a positive number");
|
|
}
|
|
return radiansToLength(lengthToRadians(length, originalUnit), finalUnit);
|
|
}
|
|
exports.convertLength = convertLength;
|
|
/**
|
|
* Converts a area to the requested unit.
|
|
* Valid units: kilometers, kilometres, meters, metres, centimetres, millimeters, acres, miles, yards, feet, inches
|
|
* @param {number} area to be converted
|
|
* @param {Units} [originalUnit="meters"] of the distance
|
|
* @param {Units} [finalUnit="kilometers"] returned unit
|
|
* @returns {number} the converted distance
|
|
*/
|
|
function convertArea(area, originalUnit, finalUnit) {
|
|
if (originalUnit === void 0) { originalUnit = "meters"; }
|
|
if (finalUnit === void 0) { finalUnit = "kilometers"; }
|
|
if (!(area >= 0)) {
|
|
throw new Error("area must be a positive number");
|
|
}
|
|
var startFactor = exports.areaFactors[originalUnit];
|
|
if (!startFactor) {
|
|
throw new Error("invalid original units");
|
|
}
|
|
var finalFactor = exports.areaFactors[finalUnit];
|
|
if (!finalFactor) {
|
|
throw new Error("invalid final units");
|
|
}
|
|
return (area / startFactor) * finalFactor;
|
|
}
|
|
exports.convertArea = convertArea;
|
|
/**
|
|
* isNumber
|
|
*
|
|
* @param {*} num Number to validate
|
|
* @returns {boolean} true/false
|
|
* @example
|
|
* turf.isNumber(123)
|
|
* //=true
|
|
* turf.isNumber('foo')
|
|
* //=false
|
|
*/
|
|
function isNumber(num) {
|
|
return !isNaN(num) && num !== null && !Array.isArray(num) && !/^\s*$/.test(num);
|
|
}
|
|
exports.isNumber = isNumber;
|
|
/**
|
|
* isObject
|
|
*
|
|
* @param {*} input variable to validate
|
|
* @returns {boolean} true/false
|
|
* @example
|
|
* turf.isObject({elevation: 10})
|
|
* //=true
|
|
* turf.isObject('foo')
|
|
* //=false
|
|
*/
|
|
function isObject(input) {
|
|
return (!!input) && (input.constructor === Object);
|
|
}
|
|
exports.isObject = isObject;
|
|
/**
|
|
* Validate BBox
|
|
*
|
|
* @private
|
|
* @param {Array<number>} bbox BBox to validate
|
|
* @returns {void}
|
|
* @throws Error if BBox is not valid
|
|
* @example
|
|
* validateBBox([-180, -40, 110, 50])
|
|
* //=OK
|
|
* validateBBox([-180, -40])
|
|
* //=Error
|
|
* validateBBox('Foo')
|
|
* //=Error
|
|
* validateBBox(5)
|
|
* //=Error
|
|
* validateBBox(null)
|
|
* //=Error
|
|
* validateBBox(undefined)
|
|
* //=Error
|
|
*/
|
|
function validateBBox(bbox) {
|
|
if (!bbox) {
|
|
throw new Error("bbox is required");
|
|
}
|
|
if (!Array.isArray(bbox)) {
|
|
throw new Error("bbox must be an Array");
|
|
}
|
|
if (bbox.length !== 4 && bbox.length !== 6) {
|
|
throw new Error("bbox must be an Array of 4 or 6 numbers");
|
|
}
|
|
bbox.forEach(function (num) {
|
|
if (!isNumber(num)) {
|
|
throw new Error("bbox must only contain numbers");
|
|
}
|
|
});
|
|
}
|
|
exports.validateBBox = validateBBox;
|
|
/**
|
|
* Validate Id
|
|
*
|
|
* @private
|
|
* @param {string|number} id Id to validate
|
|
* @returns {void}
|
|
* @throws Error if Id is not valid
|
|
* @example
|
|
* validateId([-180, -40, 110, 50])
|
|
* //=Error
|
|
* validateId([-180, -40])
|
|
* //=Error
|
|
* validateId('Foo')
|
|
* //=OK
|
|
* validateId(5)
|
|
* //=OK
|
|
* validateId(null)
|
|
* //=Error
|
|
* validateId(undefined)
|
|
* //=Error
|
|
*/
|
|
function validateId(id) {
|
|
if (!id) {
|
|
throw new Error("id is required");
|
|
}
|
|
if (["string", "number"].indexOf(typeof id) === -1) {
|
|
throw new Error("id must be a number or a string");
|
|
}
|
|
}
|
|
exports.validateId = validateId;
|
|
// Deprecated methods
|
|
function radians2degrees() {
|
|
throw new Error("method has been renamed to `radiansToDegrees`");
|
|
}
|
|
exports.radians2degrees = radians2degrees;
|
|
function degrees2radians() {
|
|
throw new Error("method has been renamed to `degreesToRadians`");
|
|
}
|
|
exports.degrees2radians = degrees2radians;
|
|
function distanceToDegrees() {
|
|
throw new Error("method has been renamed to `lengthToDegrees`");
|
|
}
|
|
exports.distanceToDegrees = distanceToDegrees;
|
|
function distanceToRadians() {
|
|
throw new Error("method has been renamed to `lengthToRadians`");
|
|
}
|
|
exports.distanceToRadians = distanceToRadians;
|
|
function radiansToDistance() {
|
|
throw new Error("method has been renamed to `radiansToLength`");
|
|
}
|
|
exports.radiansToDistance = radiansToDistance;
|
|
function bearingToAngle() {
|
|
throw new Error("method has been renamed to `bearingToAzimuth`");
|
|
}
|
|
exports.bearingToAngle = bearingToAngle;
|
|
function convertDistance() {
|
|
throw new Error("method has been renamed to `convertLength`");
|
|
}
|
|
exports.convertDistance = convertDistance;
|
|
|