@types/turf
Version:
TypeScript definitions for Turf 3.5.2
1,282 lines (1,153 loc) • 47.5 kB
TypeScript
// Type definitions for Turf 3.5.2
// Project: http://turfjs.org/
// Definitions by: Guillaume Croteau <https://github.com/gcroteau>, Denis Carriere <https://github.com/DenisCarriere>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// <reference types="geojson" />
/**
#### TODO:
Update all methods with newest JSDocs & tests based on the latest TurfJS library.
AGGREGATION
- [x] collect
MEASUREMENT
- [ ] along
- [ ] area
- [ ] bboxPolygon
- [ ] bearing
- [ ] center
- [ ] centroid
- [ ] destination
- [ ] distance
- [ ] envelope
- [ ] lineDistance
- [ ] midpoint
- [ ] pointOnSurface
- [ ] square
TRANSFORMATION
- [ ] bezier
- [ ] buffer
- [ ] concave
- [ ] convex
- [ ] difference
- [ ] intersect
- [ ] simplify
- [ ] union
MISC
- [ ] combine
- [ ] explode
- [ ] flip
- [ ] kinks
- [ ] lineSlice
- [ ] pointOnLine
HELPER
- [x] featureCollection
- [x] feature
- [x] lineString
- [x] multiLineString
- [x] point
- [x] multiPoint
- [x] polygon
- [x] multiPolygon
- [x] geometryCollection
DATA
- [x] random
- [x] sample
INTERPOLATION
- [ ] isolines
- [ ] planepoint
- [ ] tin
JOINS
- [x] inside
- [x] tag
- [ ] within
GRIDS
- [x] hexGrid
- [x] pointGrid
- [x] squareGrid
- [x] triangleGrid
CLASSIFICATION
- [ ] nearest
META
- [ ] propEach
- [ ] coordEach
- [ ] coordReduce
- [ ] featureEach
- [ ] getCoord
ASSERTIONS
- [ ] featureOf
- [ ] collectionOf
- [x] bbox
- [x] circle
- [x] geojsonType
- [x] propReduce
- [x] coordAll
- [x] tesselate
*/
declare const turf: turf.TurfStatic;
declare const TemplateUnits: 'miles' | 'nauticalmiles' | 'degrees' | 'radians' | 'inches' | 'yards' | 'meters' | 'metres' | 'kilometers' | 'kilometres'
declare const TemplateType: 'point'| 'points' | 'polygon' | 'polygons'
declare interface OptionsRandom {
bbox?: Array<number>
num_vertices?: number
max_radial_length?: number
}
declare type PropReduceCallback = (memo: any, coord: GeoJSON.Feature<any> | GeoJSON.FeatureCollection<any>) => any
declare module turf {
interface TurfStatic {
//////////////////////////////////////////////////////
// Aggregation
//////////////////////////////////////////////////////
/**
* Merges a specified property from a FeatureCollection of points into a FeatureCollection of polygons. Given an `inProperty` on points and an `outProperty` for polygons, this finds every point that lies within each polygon, collects the `inProperty` values from those points, and adds them as an array to `outProperty` on the polygon.
*
* @name [collect](http://turfjs.org/docs/#collect)
* @param {FeatureCollection<Polygon>} polygons polygons with values on which to aggregate
* @param {FeatureCollection<Point>} points points to be aggregated
* @param {string} inProperty property to be nested from
* @param {string} outProperty property to be nested into
* @return {FeatureCollection<Polygon>} polygons with properties listed based on `outField`
* @example
* var poly1 = polygon([[[0,0],[10,0],[10,10],[0,10],[0,0]]])
* var poly2 = polygon([[[10,0],[20,10],[20,20],[20,0],[10,0]]])
* var polyFC = featurecollection([poly1, poly2])
* var pt1 = point([5,5], {population: 200})
* var pt2 = point([1,3], {population: 600})
* var pt3 = point([14,2], {population: 100})
* var pt4 = point([13,1], {population: 200})
* var pt5 = point([19,7], {population: 300})
* var ptFC = featurecollection([pt1, pt2, pt3, pt4, pt5])
* var aggregated = aggregate(polyFC, ptFC, 'population', 'values')
*
* aggregated.features[0].properties.values // => [200, 600])
*/
collect(
polygons: GeoJSON.FeatureCollection<GeoJSON.Polygon>,
points: GeoJSON.FeatureCollection<GeoJSON.Point>,
inProperty: string,
outProperty: string
): GeoJSON.FeatureCollection<GeoJSON.Polygon>;
//////////////////////////////////////////////////////
// Measurement
//////////////////////////////////////////////////////
/**
* Takes a line and returns a point at a specified distance along the line.
* @param line Input line
* @param distance Distance along the line
* @param [units=miles] 'miles', 'kilometers', 'radians' or 'degrees'
* @returns Point along the line
*/
along(
line: GeoJSON.Feature<GeoJSON.LineString>,
distance: number,
units?: typeof TemplateUnits
): GeoJSON.Feature<GeoJSON.Point>;
/**
* Takes one or more features and returns their area in square meters.
* @param input Input features
* @returns Area in square meters
*/
area(input: GeoJSON.Feature<any> | GeoJSON.FeatureCollection<any>): number;
/**
* Takes a set of features, calculates the bbox of all input features, and returns a bounding box.
*
* @name bbox
* @param {(Feature|FeatureCollection)} geojson input features
* @return {Array<number>} bbox extent in [minX, minY, maxX, maxY] order
* @example
* var pt1 = point([114.175329, 22.2524])
* var pt2 = point([114.170007, 22.267969])
* var pt3 = point([114.200649, 22.274641])
* var pt4 = point([114.200649, 22.274641])
* var pt5 = point([114.186744, 22.265745])
* var features = featureCollection([pt1, pt2, pt3, pt4, pt5])
*
* var bbox = turf.bbox(features);
*
* var bboxPolygon = turf.bboxPolygon(bbox);
*
* //=bbox
*
* //=bboxPolygon
*/
bbox(bbox: GeoJSON.Feature<any> | GeoJSON.FeatureCollection<any>): Array<number>;
/**
* Takes a {@link Point} and calculates the circle polygon given a radius in degrees, radians, miles, or kilometers; and steps for precision.
*
* @name circle
* @param {Feature<Point>} center center point
* @param {number} radius radius of the circle
* @param {number} [steps=64] number of steps
* @param {string} [units=kilometers] miles, kilometers, degrees, or radians
* @returns {Feature<Polygon>} circle polygon
* @example
* var center = point([-75.343, 39.984]);
* var radius = 5;
* var steps = 10;
* var units = 'kilometers';
*
* var circle = turf.circle(center, radius, steps, units);
*
* //=circle
*/
circle(center: GeoJSON.Feature<GeoJSON.Point>, radius: number, steps?: number, units?: typeof TemplateUnits): GeoJSON.Feature<GeoJSON.Polygon>;
/**
* Enforce expectations about types of GeoJSON objects for Turf.
*
* @name geojsonType
* @param {GeoJSON} value any GeoJSON object
* @param {string} type expected GeoJSON type
* @param {string} name name of calling function
* @throws {Error} if value is not the expected type.
*/
geojsonType(value: GeoJSON.Feature<any> | GeoJSON.FeatureCollection<any>, type: string, name: string): void
/**
* Reduce properties in any GeoJSON object into a single value, similar to how Array.reduce works. However, in this case we lazily run the reduction, so an array of all properties is unnecessary.
*
* @name propReduce
* @param {GeoJSON} layer any GeoJSON object
* @param {Function} callback a method that takes (memo, coord) and returns a new memo
* @param {*} memo the starting value of memo: can be any type.
* @return {*} combined value
*/
propReduce(layer: GeoJSON.Feature<any> | GeoJSON.FeatureCollection<any>, callback: PropReduceCallback, memo: any): any
/**
* Get all coordinates from any GeoJSON object, returning an array of coordinate arrays.
*
* @name coordAll
* @param {GeoJSON} layer any GeoJSON object
* @returns {Array<Array<Number>>} coordinate position array
*/
coordAll(layer: GeoJSON.Feature<any> | GeoJSON.FeatureCollection<any>): Array<Array<number>>
/**
* Tesselates a {@link Feature<Polygon>} into a {@link FeatureCollection<Polygon>} of triangles using [earcut](https://github.com/mapbox/earcut).
*
* @name tesselate
* @param {Feature<Polygon>} polygon the polygon to tesselate
* @returns {FeatureCollection<Polygon>} a geometrycollection feature
* @example
* var polygon = turf.random('polygon').features[0];
*
* var triangles = turf.tesselate(polygon);
*
* //=triangles
*/
tesselate(poly: GeoJSON.Feature<GeoJSON.Polygon>): GeoJSON.FeatureCollection<GeoJSON.Polygon>
/**
* Takes a bbox and returns an equivalent polygon.
* @param bbox An Array of bounding box coordinates in the form: [xLow, yLow, xHigh, yHigh]
* @returns A Polygon representation of the bounding box
*/
bboxPolygon(bbox: Array<number>): GeoJSON.Feature<GeoJSON.Polygon>;
/**
* Takes two points and finds the geographic bearing between them.
* @param start Starting Point
* @param end Ending point
* @returns Bearing in decimal degrees
*/
bearing(start: GeoJSON.Feature<GeoJSON.Point>, end: GeoJSON.Feature<GeoJSON.Point>): number;
/**
* Takes a FeatureCollection and returns the absolute center point of all features.
* @param features Input features
* @returns A Point feature at the absolute center point of all input features
*/
center(features: GeoJSON.FeatureCollection<any>): GeoJSON.Feature<GeoJSON.Point>;
/**
* Takes one or more features and calculates the centroid using the arithmetic mean of all vertices.
* This lessens the effect of small islands and artifacts when calculating the centroid of a set of polygons.
* @param features Input features
* @returns The centroid of the input features
*/
centroid(features: GeoJSON.Feature<any> | GeoJSON.FeatureCollection<any>): GeoJSON.Feature<GeoJSON.Point>;
/**
* Takes a Point and calculates the location of a destination point given a distance in degrees, radians, miles, or kilometers and bearing in degrees.
* This uses the Haversine formula to account for global curvature.
* @param start Starting point
* @param distance Distance from the starting point
* @param bearing Ranging from -180 and 180
* @param units 'miles', 'kilometers', 'radians', or 'degrees'
* @returns Destination point
*/
destination(
start: GeoJSON.Feature<GeoJSON.Point>,
distance: number,
bearing: number,
units?: typeof TemplateUnits
): GeoJSON.Feature<GeoJSON.Point>;
/**
* Calculates the distance between two points in degress, radians, miles, or kilometers.
* This uses the Haversine formula to account for global curvature.
* @param from Origin point
* @param to Destination point
* @param [units=kilometers] 'miles', 'kilometers', 'radians', or 'degrees'
* @returns Distance between the two points
*/
distance(
from: GeoJSON.Feature<GeoJSON.Point>,
to: GeoJSON.Feature<GeoJSON.Point>,
units?: typeof TemplateUnits
): number;
/**
* Takes any number of features and returns a rectangular Polygon that encompasses all vertices.
* @param fc Input features
* @returns A rectangular Polygon feature that encompasses all vertices
*/
envelope(fc: GeoJSON.FeatureCollection<any>): GeoJSON.Feature<GeoJSON.Polygon>;
/**
* Takes a line and measures its length in the specified units.
* @param line Line to measure
* @param units 'miles', 'kilometers', 'radians', or 'degrees'
* @returns Length of the input line
*/
lineDistance(
line: GeoJSON.Feature<GeoJSON.LineString>,
units?: typeof TemplateUnits
): number;
/**
* Takes two points and returns a point midway between them.
* @param pt1 First point
* @param pt2 Second point
* @returns A point midway between pt1 and pt2
*/
midpoint(pt1: GeoJSON.Feature<GeoJSON.Point>, pt2: GeoJSON.Feature<GeoJSON.Point>): GeoJSON.Feature<GeoJSON.Point>;
/**
* Takes a feature and returns a Point guaranteed to be on the surface of the feature. Given a Polygon, the point will be in the area of the polygon.
* Given a LineString, the point will be along the string. Given a Point, the point will the same as the input.
* @param input Any feature or set of features
* @returns A point on the surface of input
*/
pointOnSurface(input: GeoJSON.Feature<any> | GeoJSON.FeatureCollection<any>): GeoJSON.Feature<any>;
/**
* Takes a bounding box and calculates the minimum square bounding box that would contain the input.
* @param bbox A bounding box
* @returns A square surrounding bbox
*/
square(bbox: Array<number>): Array<number>;
//////////////////////////////////////////////////////
// Transformation
//////////////////////////////////////////////////////
/**
* Takes a line and returns a curved version by applying a Bezier spline algorithm.
* The bezier spline implementation is by Leszek Rybicki.
* @param line Input LineString
* @param [resolution=10000] Time in milliseconds between points
* @param [sharpness=0.85] A measure of how curvy the path should be between splines
* @returns Curved line
*/
bezier(line: GeoJSON.Feature<GeoJSON.LineString>, resolution?: number, sharpness?: number): GeoJSON.Feature<GeoJSON.LineString>;
/**
* Calculates a buffer for input features for a given radius. Units supported are miles, kilometers, and degrees.
* @param feature Input to be buffered
* @param distance Distance to draw the buffer
* @param units 'miles', 'kilometers', 'radians', or 'degrees'
* @returns Buffered features
*/
buffer(feature: GeoJSON.Feature<GeoJSON.Polygon>, distance: number, units?: typeof TemplateUnits): GeoJSON.Feature<GeoJSON.Polygon>;
buffer(feature: GeoJSON.Feature<GeoJSON.MultiPolygon>, distance: number, units?: typeof TemplateUnits): GeoJSON.Feature<GeoJSON.MultiPolygon>;
buffer(feature: GeoJSON.Feature<GeoJSON.Point>, distance: number, units?: typeof TemplateUnits): GeoJSON.Feature<GeoJSON.Point>;
buffer(feature: GeoJSON.Feature<any>, distance: number, units?: typeof TemplateUnits): GeoJSON.Feature<any>;
buffer(feature: GeoJSON.FeatureCollection<GeoJSON.Polygon>, distance: number, units?: typeof TemplateUnits): GeoJSON.FeatureCollection<GeoJSON.Polygon>;
buffer(feature: GeoJSON.FeatureCollection<GeoJSON.MultiPolygon>, distance: number, units?: typeof TemplateUnits): GeoJSON.FeatureCollection<GeoJSON.MultiPolygon>;
buffer(feature: GeoJSON.FeatureCollection<GeoJSON.Point>, distance: number, units?: typeof TemplateUnits): GeoJSON.FeatureCollection<GeoJSON.Point>;
buffer(feature: GeoJSON.FeatureCollection<any>, distance: number, units?: typeof TemplateUnits): GeoJSON.FeatureCollection<any>;
/**
* Takes a set of points and returns a concave hull polygon. Internally, this implements a Monotone chain algorithm.
* @param points Input points
* @param maxEdge The size of an edge necessary for part of the hull to become concave (in miles)
* @param units Used for maxEdge distance (miles or kilometers)
* @returns A concave hull
*/
concave(
points: GeoJSON.FeatureCollection<GeoJSON.Point>,
maxEdge: number,
units?: typeof TemplateUnits
): GeoJSON.Feature<GeoJSON.Polygon>;
/**
* Takes a set of points and returns a convex hull polygon. Internally this uses the convex-hull module that implements a monotone chain hull.
* @param input Input points
* @returns A convex hull
*/
convex(
input: GeoJSON.FeatureCollection<GeoJSON.Point>
): GeoJSON.Feature<GeoJSON.Polygon>;
/**
* Finds the difference between two polygons by clipping the second polygon from the first.
* @param poly1 Input Polygon feaure
* @param poly2 Polygon feature to difference from poly1
* @returns A Polygon feature showing the area of poly1 excluding the area of poly2
*/
difference(
poly1: GeoJSON.Feature<GeoJSON.Polygon>,
poly2: GeoJSON.Feature<GeoJSON.Polygon>
): GeoJSON.Feature<GeoJSON.Polygon>;
/**
* Takes two Features and finds their intersection.
* If they share a border, returns the border if they don't intersect, returns undefined.
*
* @name [intersect](http://turfjs.org/docs/#intersect)
* @param {Feature<Polygon>} poly1
* @param {Feature<Polygon>} poly2
* @returns {Feature|undefined} A feature representing the point(s) they share (in case of a {Point} or {MultiPoint}), the borders they share (in case of a {LineString} or a {MultiLineString}), the area they share (in case of {Polygon} or {MultiPolygon}). If they do not share any point, returns `undefined`.
* @example
* var poly1 = polygon([[
* [-122.801742, 45.48565],
* [-122.801742, 45.60491],
* [-122.584762, 45.60491],
* [-122.584762, 45.48565],
* [-122.801742, 45.48565]
* ]]);
*
* var poly2 = polygon([[
* [-122.520217, 45.535693],
* [-122.64038, 45.553967],
* [-122.720031, 45.526554],
* [-122.669906, 45.507309],
* [-122.723464, 45.446643],
* [-122.532577, 45.408574],
* [-122.487258, 45.477466],
* [-122.520217, 45.535693]
* ]]);
* var polygons = featureCollection([poly1, poly2]);
*
* var intersection = turf.intersect(poly1, poly2);
*
* //=polygons
*
* //=intersection
*/
intersect(
feature1: GeoJSON.Feature<GeoJSON.Polygon>,
feature2: GeoJSON.Feature<GeoJSON.Polygon>
): GeoJSON.Feature<GeoJSON.Point | GeoJSON.LineString | GeoJSON.Polygon>;
intersect(
feature1: GeoJSON.Feature<any>,
feature2: GeoJSON.Feature<any>
): GeoJSON.Feature<any>;
/**
* Takes a LineString or Polygon and returns a simplified version.
* Internally uses simplify-js to perform simplification.
* @param feature Feature to be simplified
* @param tolerance Simplification tolerance
* @param highQuality Whether or not to spend more time to create a higher-quality simplification with a different algorithm
* @returns A simplified feature
*/
simplify(feature: GeoJSON.Feature<any> | GeoJSON.FeatureCollection<any> | GeoJSON.GeometryCollection, tolerance: number, highQuality: boolean): GeoJSON.Feature<any> | GeoJSON.FeatureCollection<any> | GeoJSON.GeometryCollection;
/**
* Takes two polygons and returns a combined polygon.
* If the input polygons are not contiguous, this function returns a MultiPolygon feature.;
* @param poly1 Input polygon
* @param poly2 Another input polygon
* @returns A combined Polygon or MultiPolygon feature
*/
union(poly1: GeoJSON.Feature<GeoJSON.Polygon>, poly2: GeoJSON.Feature<GeoJSON.Polygon>): GeoJSON.Feature<GeoJSON.Polygon | GeoJSON.MultiPolygon>;
//////////////////////////////////////////////////////
// Misc
//////////////////////////////////////////////////////
/**
* Combines a FeatureCollection of Point, LineString, or Polygon features into MultiPoint, MultiLineString, or MultiPolygon features.
* @param fc A FeatureCollection of any type
* @returns A FeatureCollection of corresponding type to input
*/
combine(fc: GeoJSON.FeatureCollection<any>): GeoJSON.FeatureCollection<any>;
/**
* Takes a feature or set of features and returns all positions as points.
* @param input Input features
* @returns Points representing the exploded input features
*/
explode(input: GeoJSON.Feature<any> | GeoJSON.FeatureCollection<any>): GeoJSON.FeatureCollection<GeoJSON.Point>;
/**
* Takes input features and flips all of their coordinates from [x, y] to [y, x].
* @param input Input features
* @returns A feature or set of features of the same type as input with flipped coordinates
*/
flip(input: GeoJSON.Feature<any> | GeoJSON.FeatureCollection<any>): GeoJSON.Feature<any> | GeoJSON.FeatureCollection<any>;
/**
* Takes a polygon and returns points at all self-intersections.
* @param polygon Input polygon
* @returns Self-intersections
*/
kinks(polygon: GeoJSON.Feature<GeoJSON.Polygon>): GeoJSON.FeatureCollection<GeoJSON.Point>;
/**
* Takes a line, a start Point, and a stop point and returns the line in between those points.
* @param point1 Starting point
* @param point2 Stopping point
* @param line Line to slice
* @returns Sliced line
*/
lineSlice(point1: GeoJSON.Feature<GeoJSON.Point>, point2: GeoJSON.Feature<GeoJSON.Point>, line: GeoJSON.Feature<GeoJSON.LineString>): GeoJSON.Feature<GeoJSON.LineString>;
/**
* Takes a Point and a LineString and calculates the closest Point on the LineString.
* @param line Line to snap to
* @param point Point to snap from
* @returns Closest point on the line to point
*/
pointOnLine(line: GeoJSON.Feature<GeoJSON.LineString>, point: GeoJSON.Feature<GeoJSON.Point>): GeoJSON.Feature<GeoJSON.Point>;
//////////////////////////////////////////////////////
// Helper
//////////////////////////////////////////////////////
/**
* Takes one or more {@link Feature|Features} and creates a {@link FeatureCollection}.
*
* @name [featureCollection](http://turfjs.org/docs/#featurecollection)
* @param {Feature[]} features input features
* @returns {FeatureCollection} a FeatureCollection of input features
* @example
* var features = [
* turf.point([-75.343, 39.984], {name: 'Location A'}),
* turf.point([-75.833, 39.284], {name: 'Location B'}),
* turf.point([-75.534, 39.123], {name: 'Location C'})
* ]
*
* var fc = turf.featureCollection(features)
*
* //=fc
*/
featureCollection(features: Array<GeoJSON.Feature<any>>): GeoJSON.FeatureCollection<any>;
/**
* Wraps a GeoJSON {@link Geometry} in a GeoJSON {@link Feature}.
*
* @name [feature](http://turfjs.org/docs/#feature)
* @param {Geometry} geometry input geometry
* @param {Object} properties properties
* @returns {FeatureCollection} a FeatureCollection of input features
* @example
* var geometry = {
* "type": "Point",
* "coordinates": [
* 67.5,
* 32.84267363195431
* ]
* }
*
* var feature = turf.feature(geometry)
*
* //=feature
*/
feature(geometry:GeoJSON.Feature<any>, properties?: any): GeoJSON.Feature<any>;
/**
* Creates a {@link LineString} based on a coordinate array. Properties can be added optionally.
*
* @name [lineString](http://turfjs.org/docs/#linestring)
* @param {Array<Array<number>>} coordinates an array of Positions
* @param {Object=} properties an Object of key-value pairs to add as properties
* @returns {Feature<LineString>} a LineString feature
* @throws {Error} if no coordinates are passed
* @example
* var linestring1 = turf.lineString([
* [-21.964416, 64.148203],
* [-21.956176, 64.141316],
* [-21.93901, 64.135924],
* [-21.927337, 64.136673]
* ])
* var linestring2 = turf.lineString([
* [-21.929054, 64.127985],
* [-21.912918, 64.134726],
* [-21.916007, 64.141016],
* [-21.930084, 64.14446]
* ], {name: 'line 1', distance: 145})
*
* //=linestring1
*
* //=linestring2
*/
lineString(coordinates: Array<Array<number>>, properties?: any): GeoJSON.Feature<GeoJSON.LineString>;
/**
* Creates a {@link Feature<MultiLineString>} based on a coordinate array. Properties can be added optionally.
*
* @name [multiLineString](http://turfjs.org/docs/#multilinestring)
* @param {Array<Array<Array<number>>>} coordinates an array of LineStrings
* @param {Object=} properties an Object of key-value pairs to add as properties
* @returns {Feature<MultiLineString>} a MultiLineString feature
* @throws {Error} if no coordinates are passed
* @example
* var multiLine = turf.multiLineString([[[0,0],[10,10]]])
*
* //=multiLine
*
*/
multiLineString(coordinates: Array<Array<Array<number>>>, properties?: any): GeoJSON.Feature<GeoJSON.MultiLineString>;
/**
* Takes coordinates and properties (optional) and returns a new {@link Point} feature.
*
* @name [point](http://turfjs.org/docs/#point)
* @param {Array<number>} coordinates longitude, latitude position (each in decimal degrees)
* @param {Object=} properties an Object that is used as the {@link Feature}'s
* properties
* @returns {Feature<Point>} a Point feature
* @example
* var pt1 = turf.point([-75.343, 39.984]);
*
* //=pt1
*/
point(coordinates: Array<number>, properties?: any): GeoJSON.Feature<GeoJSON.Point>;
/**
* Creates a {@link Feature<MultiPoint>} based on a coordinate array. Properties can be added optionally.
*
* @name [multiPoint](http://turfjs.org/docs/#multipoint)
* @param {Array<Array<number>>} coordinates an array of Positions
* @param {Object=} properties an Object of key-value pairs to add as properties
* @returns {Feature<MultiPoint>} a MultiPoint feature
* @throws {Error} if no coordinates are passed
* @example
* var multiPt = turf.multiPoint([[0,0],[10,10]])
*
* //=multiPt
*
*/
multiPoint(coordinates: Array<Array<number>>, properties?: any): GeoJSON.Feature<GeoJSON.MultiPoint>;
/**
* Takes an array of LinearRings and optionally an {@link Object} with properties and returns a {@link Polygon} feature.
*
* @name [polygon](http://turfjs.org/docs/#polygon)
* @param {Array<Array<Array<number>>>} coordinates an array of LinearRings
* @param {Object=} properties a properties object
* @returns {Feature<Polygon>} a Polygon feature
* @throws {Error} throw an error if a LinearRing of the polygon has too few positions
* or if a LinearRing of the Polygon does not have matching Positions at the
* beginning & end.
* @example
* var polygon = turf.polygon([[
* [-2.275543, 53.464547],
* [-2.275543, 53.489271],
* [-2.215118, 53.489271],
* [-2.215118, 53.464547],
* [-2.275543, 53.464547]
* ]], { name: 'poly1', population: 400});
*
* //=polygon
*/
polygon(coordinates: Array<Array<Array<number>>>, properties?: any): GeoJSON.Feature<GeoJSON.Polygon>;
/**
* Creates a {@link Feature<MultiPolygon>} based on a coordinate array. Properties can be added optionally.
*
* @name [multiPolygon](http://turfjs.org/docs/#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
* @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
*
*/
multiPolygon(coordinates: Array<Array<Array<Array<number>>>>, properties?: any): GeoJSON.Feature<GeoJSON.MultiPolygon>;
/**
* Creates a {@link Feature<GeometryCollection>} based on acoordinate array. Properties can be added optionally.
*
* @name [geometryCollection](http://turfjs.org/docs/#geometrycollection)
* @param {Array<{Geometry}>} geometries an array of GeoJSON Geometries
* @param {Object=} properties an Object of key-value pairs to add as properties
* @returns {Feature<GeometryCollection>} a GeoJSON GeometryCollection Feature
* @example
* var point = {
* "type": "Point",
* "coordinates": [100, 0]
* };
* var line = {
* "type": "LineString",
* "coordinates": [ [101, 0], [102, 1] ]
* };
* var collection = turf.geometryCollection([point, line]);
*
* //=collection
*/
geometryCollection(geometries: Array<GeoJSON.GeometryObject>, properties?: any): GeoJSON.GeometryCollection;
//////////////////////////////////////////////////////
// Data
//////////////////////////////////////////////////////
/**
* Generates random {@link GeoJSON} data, including {@link Point|Points} and {@link Polygon|Polygons}, for testing and experimentation.
*
* @name [random](http://turfjs.org/docs/#random)
* @param {String} [type='point'] type of features desired: 'points' or 'polygons'
* @param {Number} [count=1] how many geometries should be generated.
* @param {Object} options options relevant to the feature desired. Can include:
* @param {Array<number>} options.bbox a bounding box inside of which geometries
* are placed. In the case of {@link Point} features, they are guaranteed to be within this bounds,
* while {@link Polygon} features have their centroid within the bounds.
* @param {Number} [options.num_vertices=10] options.vertices the number of vertices added
* to polygon features.
* @param {Number} [options.max_radial_length=10] the total number of decimal
* degrees longitude or latitude that a polygon can extent outwards to
* from its center.
* @return {FeatureCollection} generated random features
* @example
* var points = turf.random('points', 100, {
* bbox: [-70, 40, -60, 60]
* })
*
* //=points
*
* var polygons = turf.random('polygons', 4, {
* bbox: [-70, 40, -60, 60]
* })
*
* //=polygons
*/
random(type?: 'point', count?: number, options?: OptionsRandom): GeoJSON.FeatureCollection<GeoJSON.Point>;
random(type?: 'points', count?: number, options?: OptionsRandom): GeoJSON.FeatureCollection<GeoJSON.Point>;
random(type?: 'polygon', count?: number, options?: OptionsRandom): GeoJSON.FeatureCollection<GeoJSON.Polygon>;
random(type?: 'polygons', count?: number, options?: OptionsRandom): GeoJSON.FeatureCollection<GeoJSON.Polygon>;
random(type?: typeof TemplateType, count?: number, options?: OptionsRandom): GeoJSON.FeatureCollection<any>;
/**
* Takes a {@link FeatureCollection} and returns a FeatureCollection with given number of {@link Feature|features} at random.
*
* @name [sample](http://turfjs.org/docs/#sample)
* @param {FeatureCollection} featurecollection set of input features
* @param {number} num number of features to select
* @return {FeatureCollection} a FeatureCollection with `n` features
* @example
* var points = turf.random('points', 1000);
*
* //=points
*
* var sample = turf.sample(points, 10);
*
* //=sample
*/
sample(featurecollection: GeoJSON.FeatureCollection<any>, num: number): GeoJSON.FeatureCollection<any>;
//////////////////////////////////////////////////////
// GRIDS
//////////////////////////////////////////////////////
/**
* Takes a bounding box and a cell size in degrees and returns a {@link FeatureCollection} of flat-topped hexagons ({@link Polygon} features) aligned in an "odd-q" vertical grid as described in [Hexagonal Grids](http://www.redblobgames.com/grids/hexagons/).
*
* @name [hexGrid](http://turfjs.org/docs/#hexgrid)
* @param {Array<number>} bbox bounding box in [minX, minY, maxX, maxY] order
* @param {number} cellSize dimension of cell in specified units
* @param {string} units used in calculating cellSize ('miles' or 'kilometers')
* @param {boolean} triangles whether to return as triangles instead of hexagons
* @return {FeatureCollection<Polygon>} a hexagonal grid
* @example
* var bbox = [-96,31,-84,40];
* var cellSize = 50;
* var units = 'miles';
*
* var hexgrid = turf.hexGrid(bbox, cellSize, units);
*
* //=hexgrid
*/
hexGrid(
bbox: Array<number>,
cellSize: number,
units?: typeof TemplateUnits,
triangles?: boolean
): GeoJSON.FeatureCollection<GeoJSON.Polygon>;
/**
* Takes a bounding box and a cell depth and returns a set of {@link Point|points} in a grid.
*
* @name [pointGrid](http://turfjs.org/docs/#pointgrid)
* @param {Array<number>} bbox extent in [minX, minY, maxX, maxY] order
* @param {number} cellSize the distance across each cell
* @param {string} [units=kilometers] used in calculating cellSize, can be degrees, radians, miles, or kilometers
* @return {FeatureCollection<Point>} grid of points
* @example
* var extent = [-70.823364, -33.553984, -70.473175, -33.302986];
* var cellSize = 3;
* var units = 'miles';
*
* var grid = turf.pointGrid(extent, cellSize, units);
*
* //=grid
*/
pointGrid(
bbox: Array<number>,
cellSize: number,
units?: typeof TemplateUnits
): GeoJSON.FeatureCollection<GeoJSON.Point>;
/**
* Takes a bounding box and a cell depth and returns a set of square {@link Polygon|polygons} in a grid.
*
* @name [squareGrid](http://turfjs.org/docs/#squaregrid)
* @param {Array<number>} bbox extent in [minX, minY, maxX, maxY] order
* @param {number} cellSize width of each cell
* @param {string} [units=kilometers] used in calculating cellSize, can be degrees, radians, miles, or kilometers
* @return {FeatureCollection<Polygon>} grid a grid of polygons
* @example
* var bbox = [-96,31,-84,40]
* var cellSize = 10
* var units = 'miles'
*
* var squareGrid = turf.squareGrid(bbox, cellSize, units)
*
* //=squareGrid
*/
squareGrid(
bbox: Array<number>,
cellSize: number,
units?: typeof TemplateUnits
): GeoJSON.FeatureCollection<GeoJSON.Polygon>;
/**
* Takes a bounding box and a cell depth and returns a set of triangular {@link Polygon|polygons} in a grid.
*
* @name [triangleGrid](http://turfjs.org/docs/#trianglegrid))
* @param {Array<number>} bbox extent in [minX, minY, maxX, maxY] order
* @param {number} cellSize dimension of each cell
* @param {string} [units=kilometers] used in calculating cellSize, can be degrees, radians, miles, or kilometers
* @return {FeatureCollection<Polygon>} grid of polygons
* @example
* var bbox = [-96,31,-84,40]
* var cellSize = 10;
* var units = 'miles';
*
* var triangleGrid = turf.triangleGrid(extent, cellSize, units);
*
* //=triangleGrid
*/
triangleGrid(
bbox: Array<number>,
cellSize: number,
units?: typeof TemplateUnits
): GeoJSON.FeatureCollection<GeoJSON.Polygon>;
//////////////////////////////////////////////////////
// Interpolation
//////////////////////////////////////////////////////
/**
* Takes points with z-values and an array of value breaks and generates isolines.
* @param points Input points
* @param z The property name in points from which z-values will be pulled
* @param resolution Resolution of the underlying grid
* @param breaks Where to draw contours
* @returns Isolines
*/
isolines(points: GeoJSON.FeatureCollection<GeoJSON.Point>, z: string, resolution: number, breaks: Array<number>): GeoJSON.FeatureCollection<GeoJSON.LineString>;
/**
* Takes a triangular plane as a Polygon and a Point within that triangle and returns the z-value at that point.
* The Polygon needs to have properties a, b, and c that define the values at its three corners.
* @param interpolatedPoint The Point for which a z-value will be calculated
* @param triangle A Polygon feature with three vertices
* @returns The z-value for interpolatedPoint
*/
planepoint(interpolatedpoint: GeoJSON.Feature<GeoJSON.Point>, triangle: GeoJSON.Feature<GeoJSON.Polygon>): number;
/**
* Takes a set of points and the name of a z-value property and creates a Triangulated Irregular Network, or a TIN for short, returned as a collection of Polygons.
* These are often used for developing elevation contour maps or stepped heat visualizations.
* This triangulates the points, as well as adds properties called a, b, and c representing the value of the given propertyName at each of the points that represent the corners of the triangle.
* @param points Input points
* @param [propertyName] Name of the property from which to pull z values This is optional: if not given, then there will be no extra data added to the derived triangles.
* @returns TIN output
*/
tin(points: GeoJSON.FeatureCollection<GeoJSON.Point>, propertyName?: string): GeoJSON.FeatureCollection<GeoJSON.Polygon>;
//////////////////////////////////////////////////////
// Joins
//////////////////////////////////////////////////////
/**
* Takes a {<Point>} and a {<Polygon>} or {<MultiPolygon>} and determines if the point resides inside the polygon. The polygon can be convex or concave. The function accounts for holes.
*
* @name [inside](http://turfjs.org/docs/#inside)
* @param {Feature<Point>} point input point
* @param {Feature<(Polygon|MultiPolygon)>} polygon input polygon or multipolygon
* @return {Boolean} `true` if the Point is inside the Polygon; `false` if the Point is not inside the Polygon
* @example
* var pt = point([-77, 44])
* var poly = polygon([[[-81, 41], [-81, 47], [-72, 47], [-72, 41], [-81, 41]]])
*
* var isInside = turf.inside(pt, poly)
*
* //=isInside
*/
inside(
point: GeoJSON.Feature<GeoJSON.Point>,
polygon: GeoJSON.Feature<GeoJSON.Polygon>
): boolean;
/**
* Takes a {FeatureCollection<Point>} and a {FeatureCollection<Polygon>} and performs a spatial join.
*
* @name [tag](http://turfjs.org/docs/#inside)
* @param {FeatureCollection<Point>} points input points
* @param {FeatureCollection<Polygon>} polygons input polygons
* @param {string} field property in `polygons` to add to joined {<Point>} features
* @param {string} outField property in `points` in which to store joined property from `polygons`
* @return {FeatureCollection<Point>} points with `containingPolyId` property containing values from `polyId`
* @example
* var pt1 = point([-77, 44])
* var pt2 = point([-77, 38])
* var poly1 = polygon([[[-81, 41], [-81, 47], [-72, 47], [-72, 41], [-81, 41]]], {pop: 1000})
* var poly2 = polygon([[[-81, 35], [-81, 41], [-72, 41], [-72, 35], [-81, 35]]], {pop: 3000})
*
* var points = featureCollection([pt1, pt2])
* var polygons = featureCollection([poly1, poly2])
*
* var tagged = turf.tag(points, polygons, 'pop', 'population')
* //=tagged
*/
tag(
points: GeoJSON.FeatureCollection<GeoJSON.Point>,
polygons: GeoJSON.FeatureCollection<GeoJSON.Polygon>,
field: string,
outField: string
): GeoJSON.FeatureCollection<GeoJSON.Point>;
/**
* Takes a set of points and a set of polygons and returns the points that fall within the polygons.
* @param points Input points
* @param polygons Input polygons
* @returns Points that land within at least one polygon
*/
within(
points: GeoJSON.FeatureCollection<GeoJSON.Point>,
polygons: GeoJSON.FeatureCollection<GeoJSON.Polygon>
): GeoJSON.FeatureCollection<GeoJSON.Point>;
//////////////////////////////////////////////////////
// Classification
//////////////////////////////////////////////////////
/**
* Takes a reference point and a set of points and returns the point from the set closest to the reference.
* @param point The reference point
* @param against Input point set
* @returns The closest point in the set to the reference point
*/
nearest(
point: GeoJSON.Feature<GeoJSON.Point>,
against: GeoJSON.FeatureCollection<GeoJSON.Point>
): GeoJSON.Feature<GeoJSON.Point>;
}
}
// NPM Stable version of Turf
declare module "turf" {
export = turf
}
// Latest version of Turf
declare module "@turf/turf" {
export = turf
}
// AGGREGATION
declare module "@turf/collect" {
const collect: typeof turf.collect;
export = collect;
}
// MEASUREMENT
declare module "@turf/along" {
const along: typeof turf.along;
export = along;
}
declare module "@turf/area" {
const area: typeof turf.area;
export = area;
}
declare module "@turf/bbox-polygon" {
const bboxPolygon: typeof turf.bboxPolygon;
export = bboxPolygon;
}
declare module "@turf/bearing" {
const bearing: typeof turf.bearing;
export = bearing;
}
declare module "@turf/center" {
const center: typeof turf.center;
export = center;
}
declare module "@turf/centroid" {
const centroid: typeof turf.centroid;
export = centroid;
}
declare module "@turf/destination" {
const destination: typeof turf.destination;
export = destination;
}
declare module "@turf/distance" {
const distance: typeof turf.distance;
export = distance;
}
declare module "@turf/envelope" {
const envelope: typeof turf.envelope;
export = envelope;
}
declare module "@turf/line-distance" {
const lineDistance: typeof turf.lineDistance;
export = lineDistance;
}
declare module "@turf/midpoint" {
const midpoint: typeof turf.midpoint;
export = midpoint;
}
declare module "@turf/point-on-surface" {
const pointOnSurface: typeof turf.pointOnSurface;
export = pointOnSurface;
}
declare module "@turf/square" {
const square: typeof turf.square;
export = square;
}
// TRANSFORMATION
declare module "@turf/bezier" {
const bezier: typeof turf.bezier;
export = bezier;
}
declare module "@turf/buffer" {
const buffer: typeof turf.buffer;
export = buffer;
}
declare module "@turf/concave" {
const concave: typeof turf.concave;
export = concave;
}
declare module "@turf/convex" {
const convex: typeof turf.convex;
export = convex;
}
declare module "@turf/difference" {
const difference: typeof turf.difference;
export = difference;
}
declare module "@turf/intersect" {
const intersect: typeof turf.intersect;
export = intersect;
}
declare module "@turf/simplify" {
const simplify: typeof turf.simplify;
export = simplify;
}
declare module "@turf/union" {
const union: typeof turf.union;
export = union;
}
// MISC
declare module "@turf/combine" {
const combine: typeof turf.combine;
export = combine;
}
declare module "@turf/explode" {
const explode: typeof turf.explode;
export = explode;
}
declare module "@turf/flip" {
const flip: typeof turf.flip;
export = flip;
}
declare module "@turf/kinks" {
const kinks: typeof turf.kinks;
export = kinks;
}
declare module "@turf/line-slice" {
const lineSlice: typeof turf.lineSlice;
export = lineSlice;
}
declare module "@turf/point-on-line" {
const pointOnLine: typeof turf.pointOnLine;
export = pointOnLine;
}
// HELPER
declare module "@turf/helpers" {
const helpers: {
featureCollection: typeof turf.featureCollection,
feature: typeof turf.feature,
lineString: typeof turf.lineString,
multiLineString: typeof turf.multiLineString,
point: typeof turf.point,
multiPoint: typeof turf.multiPoint,
polygon: typeof turf.polygon,
multiPolygon: typeof turf.multiPolygon,
geometryCollection: typeof turf.geometryCollection,
};
export = helpers;
}
// DATA
declare module "@turf/random" {
const random: typeof turf.random;
export = random;
}
declare module "@turf/sample" {
const sample: typeof turf.sample;
export = sample;
}
// INTERPOLATION
declare module "@turf/isolines" {
const isolines: typeof turf.isolines;
export = isolines;
}
declare module "@turf/planepoint" {
const planepoint: typeof turf.planepoint;
export = planepoint;
}
declare module "@turf/tin" {
const tin: typeof turf.tin;
export = tin;
}
// JOINS
declare module "@turf/inside" {
const inside: typeof turf.inside;
export = inside;
}
declare module "@turf/tag" {
const tag: typeof turf.tag;
export = tag;
}
declare module "@turf/within" {
const within: typeof turf.within;
export = within;
}
// GRIDS
declare module "@turf/hex-grid" {
const hexGrid: typeof turf.hexGrid;
export = hexGrid;
}
declare module "@turf/point-grid" {
const pointGrid: typeof turf.pointGrid;
export = pointGrid;
}
declare module "@turf/square-grid" {
const squareGrid: typeof turf.squareGrid;
export = squareGrid;
}
declare module "@turf/triangle-grid" {
const triangleGrid: typeof turf.triangleGrid;
export = triangleGrid;
}
// CLASSIFICATION
declare module "@turf/nearest" {
const nearest: typeof turf.nearest;
export = nearest;
}
// // META
// declare module "@turf/propEach" {
// const propEach: typeof turf.propEach;
// export = propEach;
// }
// declare module "@turf/coordEach" {
// const coordEach: typeof turf.coordEach;
// export = coordEach;
// }
// declare module "@turf/coordReduce" {
// const coordReduce: typeof turf.coordReduce;
// export = coordReduce;
// }
// declare module "@turf/featureEach" {
// const featureEach: typeof turf.featureEach;
// export = featureEach;
// }
// declare module "@turf/getCoord" {
// const getCoord: typeof turf.getCoord;
// export = getCoord;
// }
// // ASSERTIONS
// declare module "@turf/featureOf" {
// const featureOf: typeof turf.featureOf;
// export = featureOf;
// }
// declare module "@turf/collectionOf" {
// const collectionOf: typeof turf.collectionOf;
// export = collectionOf;
// }
declare module "@turf/bbox" {
const bbox: typeof turf.bbox;
export = bbox;
}
declare module "@turf/circle" {
const circle: typeof turf.circle;
export = circle;
}
declare module "@turf/geojsonType" {
const geojsonType: typeof turf.geojsonType;
export = geojsonType;
}
declare module "@turf/propReduce" {
const propReduce: typeof turf.propReduce;
export = propReduce;
}
declare module "@turf/coordAll" {
const coordAll: typeof turf.coordAll;
export = coordAll;
}
declare module "@turf/tesselate" {
const tesselate: typeof turf.tesselate;
export = tesselate;
}