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.
489 lines
19 KiB
489 lines
19 KiB
import { BBox, CollectionTypes, Feature, FeatureCollection, GeoJSONObject, Geometries, Geometry, GeometryCollection, GeometryObject, GeometryTypes, Id, LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon, Position, Properties, Types } from "./lib/geojson";
|
|
export { Id, Properties, BBox, Position, Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon, GeometryObject, GeoJSONObject, GeometryCollection, Geometry, GeometryTypes, Types, CollectionTypes, Geometries, Feature, FeatureCollection };
|
|
export declare type Coord = Feature<Point> | Point | Position;
|
|
export declare type Units = "meters" | "millimeters" | "centimeters" | "kilometers" | "acres" | "miles" | "nauticalmiles" | "inches" | "yards" | "feet" | "radians" | "degrees";
|
|
export declare type Grid = "point" | "square" | "hex" | "triangle";
|
|
export declare type Corners = "sw" | "se" | "nw" | "ne" | "center" | "centroid";
|
|
export declare type Lines = LineString | MultiLineString | Polygon | MultiPolygon;
|
|
export declare type AllGeoJSON = Feature | FeatureCollection | Geometry | GeometryCollection;
|
|
/**
|
|
* @module helpers
|
|
*/
|
|
/**
|
|
* Earth Radius used with the Harvesine formula and approximates using a spherical (non-ellipsoid) Earth.
|
|
*
|
|
* @memberof helpers
|
|
* @type {number}
|
|
*/
|
|
export declare let earthRadius: number;
|
|
/**
|
|
* Unit of measurement factors using a spherical (non-ellipsoid) earth radius.
|
|
*
|
|
* @memberof helpers
|
|
* @type {Object}
|
|
*/
|
|
export declare let factors: {
|
|
[key: string]: number;
|
|
};
|
|
/**
|
|
* Units of measurement factors based on 1 meter.
|
|
*
|
|
* @memberof helpers
|
|
* @type {Object}
|
|
*/
|
|
export declare let unitsFactors: {
|
|
[key: string]: number;
|
|
};
|
|
/**
|
|
* Area of measurement factors based on 1 square meter.
|
|
*
|
|
* @memberof helpers
|
|
* @type {Object}
|
|
*/
|
|
export declare let areaFactors: any;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function feature<G = Geometry, P = Properties>(geom: G, properties?: P, options?: {
|
|
bbox?: BBox;
|
|
id?: Id;
|
|
}): Feature<G, P>;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function geometry(type: "Point" | "LineString" | "Polygon" | "MultiPoint" | "MultiLineString" | "MultiPolygon", coordinates: any[], options?: {}): Point | LineString | Polygon | MultiPoint | MultiLineString | MultiPolygon;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function point<P = Properties>(coordinates: Position, properties?: P, options?: {
|
|
bbox?: BBox;
|
|
id?: Id;
|
|
}): Feature<Point, P>;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function points<P = Properties>(coordinates: Position[], properties?: P, options?: {
|
|
bbox?: BBox;
|
|
id?: Id;
|
|
}): FeatureCollection<Point, P>;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function polygon<P = Properties>(coordinates: Position[][], properties?: P, options?: {
|
|
bbox?: BBox;
|
|
id?: Id;
|
|
}): Feature<Polygon, P>;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function polygons<P = Properties>(coordinates: Position[][][], properties?: P, options?: {
|
|
bbox?: BBox;
|
|
id?: Id;
|
|
}): FeatureCollection<Polygon, P>;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function lineString<P = Properties>(coordinates: Position[], properties?: P, options?: {
|
|
bbox?: BBox;
|
|
id?: Id;
|
|
}): Feature<LineString, P>;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function lineStrings<P = Properties>(coordinates: Position[][], properties?: P, options?: {
|
|
bbox?: BBox;
|
|
id?: Id;
|
|
}): FeatureCollection<LineString, P>;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function featureCollection<G = Geometry, P = Properties>(features: Array<Feature<G, P>>, options?: {
|
|
bbox?: BBox;
|
|
id?: Id;
|
|
}): FeatureCollection<G, P>;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function multiLineString<P = Properties>(coordinates: Position[][], properties?: P, options?: {
|
|
bbox?: BBox;
|
|
id?: Id;
|
|
}): Feature<MultiLineString, P>;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function multiPoint<P = Properties>(coordinates: Position[], properties?: P, options?: {
|
|
bbox?: BBox;
|
|
id?: Id;
|
|
}): Feature<MultiPoint, P>;
|
|
/**
|
|
* 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
|
|
*
|
|
*/
|
|
export declare function multiPolygon<P = Properties>(coordinates: Position[][][], properties?: P, options?: {
|
|
bbox?: BBox;
|
|
id?: Id;
|
|
}): Feature<MultiPolygon, P>;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function geometryCollection<P = Properties>(geometries: Array<Point | LineString | Polygon | MultiPoint | MultiLineString | MultiPolygon>, properties?: P, options?: {
|
|
bbox?: BBox;
|
|
id?: Id;
|
|
}): Feature<GeometryCollection, P>;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function round(num: number, precision?: number): number;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function radiansToLength(radians: number, units?: Units): number;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function lengthToRadians(distance: number, units?: Units): number;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function lengthToDegrees(distance: number, units?: Units): number;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function bearingToAzimuth(bearing: number): number;
|
|
/**
|
|
* Converts an angle in radians to degrees
|
|
*
|
|
* @name radiansToDegrees
|
|
* @param {number} radians angle in radians
|
|
* @returns {number} degrees between 0 and 360 degrees
|
|
*/
|
|
export declare function radiansToDegrees(radians: number): number;
|
|
/**
|
|
* Converts an angle in degrees to radians
|
|
*
|
|
* @name degreesToRadians
|
|
* @param {number} degrees angle between 0 and 360 degrees
|
|
* @returns {number} angle in radians
|
|
*/
|
|
export declare function degreesToRadians(degrees: number): number;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function convertLength(length: number, originalUnit?: Units, finalUnit?: Units): number;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function convertArea(area: number, originalUnit?: Units, finalUnit?: Units): number;
|
|
/**
|
|
* isNumber
|
|
*
|
|
* @param {*} num Number to validate
|
|
* @returns {boolean} true/false
|
|
* @example
|
|
* turf.isNumber(123)
|
|
* //=true
|
|
* turf.isNumber('foo')
|
|
* //=false
|
|
*/
|
|
export declare function isNumber(num: any): boolean;
|
|
/**
|
|
* isObject
|
|
*
|
|
* @param {*} input variable to validate
|
|
* @returns {boolean} true/false
|
|
* @example
|
|
* turf.isObject({elevation: 10})
|
|
* //=true
|
|
* turf.isObject('foo')
|
|
* //=false
|
|
*/
|
|
export declare function isObject(input: any): boolean;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function validateBBox(bbox: any): void;
|
|
/**
|
|
* 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
|
|
*/
|
|
export declare function validateId(id: any): void;
|
|
export declare function radians2degrees(): void;
|
|
export declare function degrees2radians(): void;
|
|
export declare function distanceToDegrees(): void;
|
|
export declare function distanceToRadians(): void;
|
|
export declare function radiansToDistance(): void;
|
|
export declare function bearingToAngle(): void;
|
|
export declare function convertDistance(): void;
|
|
|