Truf.js文档整理适用于浏览器和Node.js的高级地理空间分析库。turf默认使用的是标准的geojson数据，坐

Truf.js中文文档

[TOC]

一.简介

当前版本：v7.0.0
适用于浏览器和Node.js的高级地理空间分析库
turf默认使用的是标准的geojson数据，坐标使用的是标准的 WGS84
坐标默认是经纬度【经度，纬度】// 先经度，后纬度

GeoJSON 数据ts类型定义可以用插件 @types/geojson

二.Measurement(测量)

GeoJSON

area 获取区域面积

获取一个区域的面积（单位是㎡）

用法:

turf.area(value)

参数:

value (GeoJSON): 需要获取面积的数据

返回:

(number): 面积（单位是㎡）

例子:

var polygon = turf.polygon([
  [
    [125, -15],
    [113, -22],
    [154, -27],
    [144, -15],
    [125, -15],
  ],
]);

var area = turf.area(polygon); // 3332484969239.2676

bbox 获取边界框

计算任何GeoJSON对象（包括FeatureCollection）的边界框

用法:

turf.bbox(value, options?)

参数:

value (GeoJSON): 需要获取边界的对象
options? ({ recompute?: boolean }): recompute 是否忽略geojson上的现有的bbox属性，如果不忽略并且value里面有一个bbox属性就直接用它的值，没有才去计算

返回:

[minX, minY, maxX, maxY] (Number []): 边界值

例子:

var line = turf.lineString([
  [-74, 40],
  [-78, 42],
  [-82, 35],
]);
var bbox = turf.bbox(line); // [-82, 35, -74, 42]
var bboxPolygon = turf.bboxPolygon(bbox);

// 如果line里面自己包含bbox
var line = turf.lineString([
  [-74, 40],
  [-78, 42],
  [-82, 35],
]);
line.bbox = [1, 1, 1, 1]
var bbox = turf.bbox(line); // [1, 1, 1, 1]
var bboxPolygon = turf.bboxPolygon(bbox);

// 如果recompute为true
var line = turf.lineString([
  [-74, 40],
  [-78, 42],
  [-82, 35],
]);
line.bbox = [1, 1, 1, 1]
var bbox = turf.bbox(line, {
  recompute: true
}); // [-82, 35, -74, 42]
var bboxPolygon = turf.bboxPolygon(bbox);

bboxPolygon 把边界值转为等价的polygon对象

把bbox的值转为一个等价的polygon地理数据对象

用法:

bboxPolygon(bbox, option?)

参数:

bbox ([number, number, number, number]): 边界值[minX, minY, maxX, maxY]
option? ({properties?: Object, id?: string}): 生成的polygon对象的properties值和id值

返回:

(Feature<Polygon>): 等价的polygon对象

例子:

var bbox = [0, 0, 10, 10];
var poly = turf.bboxPolygon(bbox);

envelope 获取元素边界框

接受任意数量的要素，并返回一个包围所有顶点的矩形多边形。等价于 bbox + bboxPolygon

用法:

envelope(value)

参数:

value (GeoJSON): 需要获取边界的对象

返回:

(Feature<Polygon>): 等价的polygon对象

例子:

var features = turf.featureCollection([
  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 enveloped = turf.envelope(features);

square 计算正方形边界框

接受一个边界框并计算能容纳输入的最小正方形边界框.

用法:

square(bbox)

参数:

bbox (extent in [west, south, east, north] order): 边界框

返回:

(BBox ): 正方形边界框

例子:

var bbox = [-20, -20, -15, 0];
var squared = turf.square(bbox);

计算中心 center/centerOfMass/centerMean/centerMedian

@turf/center
- 基于边界计算中心点
- finds the simple center of a dataset, by finding the midpoint between the extents of the data. That is, it divides in half the farthest east and farthest west point as well as the farthest north and farthest south.
@turf/center-of-mass
- 计算质心，（重量的中心点）
- imagines that the dataset is a sheet of paper. The center of mass is where the sheet would balance on a fingertip.
@turf/center-mean
- 所有点坐标的平均值
- takes the averages of all the coordinates and produces a value that respects that. Unlike @turf/center, it is sensitive to clusters and outliers. It lands in the statistical middle of a dataset, not the geographical. It can also be weighted, meaning certain points are more important than others.
@turf/center-median
- 所有点坐标的中位数
- takes the mean center and tries to find, iteratively, a new point that requires the least amount of travel from all the points in the dataset. It is not as sensitive to outliers as @turf/center-mean, but it is attracted to clustered data. It, too, can be weighted.

center 计算中心点

接受一个要素或要素集合，并返回所有要素的绝对中心点。

用法:

center(features, options?)

参数:

features (GeoJSON): 要素集合
options? ({properties?: Object, bbox?: Object, id?: Object}): 赋值到返回的Point对象上properties、bbox、id

返回:

(Feature<Point>): 要素集合的中心点

例子:

var features = turf.points([
  [-97.522259, 35.4691],
  [-97.502754, 35.463455],
  [-97.508269, 35.463245],
]);

var center = turf.center(features);

centerOfMass 计算质心

计算要素的质心,使用的公式：Centroid of Polygon

用法:

centerOfMass(features, options?)

参数:

features (GeoJSON): 要素集合
options? ({properties?: Object}): 赋值到返回的Point对象上properties

返回:

(Feature<Point>): 质心点

例子:

var polygon = turf.polygon([
  [
    [-81, 41],
    [-88, 36],
    [-84, 31],
    [-80, 33],
    [-77, 39],
    [-81, 41],
  ],
]);

var center = turf.centerOfMass(polygon);

centroid 计算质心

计算质心作为对象内所有顶点的平均值。

用法:

centroid(features, options?)

参数:

features (GeoJSON): 要素集合
options? ({properties?: Object}): 赋值到返回的Point对象上properties

返回:

(Feature<Point>): 质心点

例子:

var polygon = turf.polygon([
  [
    [-81, 41],
    [-88, 36],
    [-84, 31],
    [-80, 33],
    [-77, 39],
    [-81, 41],
  ],
]);

var centroid = turf.centroid(polygon);

pointsWithinPolygon 查找在落在多边形内的点

查找落在 (多)多边形内的点或多点坐标位置。

用法：

pointsWithinPolygon(points, polygons)

参数:

points (Feature | FeatureCollection<Point | MultiPoint>): 点集合
points (FeatureCollection | Geometry | Feature<Polygon | MultiPolygon>): 多边形集合

返回：

(FeatureCollection<Point | MultiPoint>) 其位置至少位于一个多边形内的点或多点。几何类型将于传入的几何类型相匹配

例子：

var points = turf.points([
  [-46.6318, -23.5523],
  [-46.6246, -23.5325],
  [-46.6062, -23.5513],
  [-46.663, -23.554],
  [-46.643, -23.557],
]);

var searchWithin = turf.polygon([
  [
    [-46.653, -23.543],
    [-46.634, -23.5346],
    [-46.613, -23.543],
    [-46.614, -23.559],
    [-46.631, -23.567],
    [-46.653, -23.56],
    [-46.653, -23.543],
  ],
]);

var ptsWithin = turf.pointsWithinPolygon(points, searchWithin);

LineString

along 获取指定距离的坐标

返回沿着管线指定距离的点的坐标

用法:

turf.along(line, distance, options?)

参数:

line (Feature<LineString>): 管线对象
distance (Number): 沿线的距离
options? ({ units?: degrees | radians | miles | kilometers }): units距离单位，默认是千米

返回:

(Feature<Point>): 指定距离的点对象

例子:

var line = turf.lineString([
  [-83, 30],
  [-84, 36],
  [-78, 41],
]);
var options = { units: "miles" };

var along = turf.along(line, 200, options); // Point([-83.4608648621918, 32.8678095806294])

length 计算线长度

用指定单位计算线的长度

用法:

length(line, options?)

参数:

line (Feature<LineString | MultiLineString): 线对象
options? ({units?: string}): units距离单位: degrees度、radians弧度、miles英里、kilometers公里（kilometers）

返回:

(Number): 线的长度

例子:

var line = turf.lineString([
  [115, -32],
  [131, -22],
  [143, -25],
  [150, -34],
]);
var length = turf.length(line, { units: "miles" }); // 2738.9663893575207

pointToLineDistance 计算点到线的最短距离

接受一个点和一条线，并返回点到线的最短距离。

用法:

pointToLineDistance(point, line, options?)

参数:

point (Feature<Point> | Array<number>): 点
line (Feature<LineString>): 线
options?.units? (string): units距离单位: degrees度、radians弧度、miles英里、kilometers公里（kilometers）
options?.method? (string): method计算方法: geodesic球面距离(spherical欧几里得距离)、planar平面距离(flat). 默认是geodesic 返回:

(Number): 点到线的最短距离

例子:

var pt = turf.point([0, 0]);
var line = turf.lineString([
  [1, 1],
  [-1, 1],
]);

var distance = turf.pointToLineDistance(pt, line, { units: "miles" });
//=69.11854715938406

nearestPointOnLine 获取点到线的最近点

提供一个Point和一个LineString，返回LineString上离Point最近的点

用法：

nearestPointOnLine(point, line, options?)

参数:

point (Feature<Point>): 点
line (Feature<LineString>): 线
options?.units? (string): 单位，默认'kilometers'

返回：

(Feature)

例子：

var line = turf.lineString([
  [-77.031669, 38.878605],
  [-77.029609, 38.881946],
  [-77.020339, 38.884084],
  [-77.025661, 38.885821],
  [-77.021884, 38.889563],
  [-77.019824, 38.892368],
]);
var pt = turf.point([-77.037076, 38.884017]);

var snapped = turf.nearestPointOnLine(line, pt, { units: "miles" });

nearestPointToLine 点集合中距线最近的点

返回点集合中距离直线最近点。返回的点有一个dist属性，表示它到直线的距离

用法：

nearestPointToLine(points, line, options?)

参数:

points (FeatureCollection | GeometryCollection<Point>): 点的集合
line (Feature | Geometry<LineString>): 线要素
options.units? (string):
options.properties? (Object):

返回：

(Feature<Point>)

例子：

var pt1 = turf.point([0, 0]);
var pt2 = turf.point([0.5, 0.5]);
var points = turf.featureCollection([pt1, pt2]);
var line = turf.lineString([
  [1, 1],
  [-1, 1],
]);

var nearest = turf.nearestPointToLine(points, line);

Point

bearing 地理方位角

获取一条直线的角度，垂直向上0，垂直向下为180，水平向左接近90，水平向右接近-90。范围-180~180

接受两个点，并找到它们之间的地理方位角，即从北方线（0度）测量的角度。

计算方法: bearing 函数计算的是两个地理点之间的大圆航线方位角（Great-circle bearing）。这是从起点到终点沿着球面最短路径（大圆路径）的方向。
适用场景: 适用于大圆航线的情况，特别是当你关心两个点之间的最短路径方向时，使用 bearing。常用于航海、航空以及需要精确计算地球表面两点之间的方向的场景。
特点: 计算出的方位角是在球面上朝向终点的最初方向。由于地球的球形，路径和方位角会随着行进而改变。

用法:

bearing(startPoint, endPoint, options?)

参数:

startPoint (Coord): 直线开始的点
endPoint (Coord): 直线结束的点
options? ({final?: boolean}): final为true时，垂直向上0，垂直向下为180，水平向左接近90，水平向右接近270. 范围0~360

返回:

(Number): 线的角度

例子:

var point1 = turf.point([-75.343, 39.984]);
var point2 = turf.point([-75.534, 39.123]);

var bearing = turf.bearing(point1, point2); // -170.2330491349224

rhumbBearing 投影方位角

取两个点，并返回他们的方位角

计算方法: rhumbBearing 函数计算的是两个地理点之间的恒向线方位角（Rhumb line bearing）。恒向线是一条在地图投影中保持恒定方向的路径，尽管它通常不是球面上的最短路径。
适用场景: 适用于需要保持恒定方向的导航场景，例如传统的航海和航空。恒向线在地图上呈现为直线，因此在这种情况下，使用 rhumbBearing。
特点: 计算出的方位角在行进过程中保持不变，这意味着从起点到终点沿着这条路径的方位角是恒定的，不会随着路径的变化而改变。

用法:

rhumbBearing(startPoint, endPoint, options?)

参数:

startPoint (Coord): 直线开始的点
endPoint (Coord): 直线结束的点
options? ({final?: boolean}): final为true时，从南向线(180度)开始测量

返回:

(Number): 线的角度，范围 -180 ~ 180 顺时针测量

例子:

var point1 = turf.point([-75.343, 39.984], { "marker-color": "#F00" });
var point2 = turf.point([-75.534, 39.123], { "marker-color": "#00F" });

var bearing = turf.rhumbBearing(point1, point2); // -170.29417535572546

destination 根据原点、地理方位角、距离计算目标点

接受一个点，并根据给定的距离（以度、弧度、英里或公里表示）和方位角（以度表示），计算目的地点的位置。这使用Haversine公式来考虑全球曲率。

计算方法: destination 函数使用大圆距离（Great-circle distance）的计算方法，从起点出发，沿着给定的方位角和距离，计算出终点的坐标。大圆路径是在球面上行进的最短路径。
适用场景: 适用于需要沿着球面最短路径前进的场景，比如航空或远距离的地理计算。
特点: 终点的计算是基于地球曲面上的最短路径，因此结果点的位置可能会偏离恒定方位线。

用法:

destination(startPoint, distance, bearing, options?)

参数:

startPoint (Coord): 原点
distance (Number): 和原点的距离
bearing (Number): 地理方位角，范围从-180 ~ 180
options? ({units?: string, properties?: Object}): units距离单位，默认是千米

返回:

(Feature<Point>): 目标点

例子:

var point = turf.point([-75.343, 39.984]);
var distance = 50;
var bearing = 90;
var options = { units: "miles" };

var destination = turf.destination(point, distance, bearing, options);

rhumbDestination 根据原点、投影方位角、距离计算目标点

接受一个点，并根据给定的距离（以度、弧度、英里或公里表示）和方位角（以度表示），计算目的地点的位置

计算方法: rhumbDestination 函数使用恒向线（Rhumb line）的计算方法，即在保持固定方位角的情况下，从起点沿指定距离前进来计算终点坐标。恒向线是地图上的一条直线，但在地球的曲面上并不是最短路径。
适用场景: 适用于需要保持恒定方向的场景，例如传统的航海或短距离导航场景。
特点: 终点的计算基于固定的方位角，不随路径的变化而改变，因此路径是直线的（在地图投影上）。

distance 两点之间的地理最短距离

计算两点之间的大地球形最短距离,单位可以是度degrees、弧度radians、英里miles或公里kilometers。这使用Haversine公式来考虑全球曲率。

计算方法: distance 函数使用的是大圆距离（Great-circle distance，也称为Haversine distance）来计算两个地理点之间的最短路径。
适用场景: 大圆距离适用于地球表面两点之间的最短距离，这条路径通常是曲线，尤其是在远距离的情况下。它适用于大部分需要准确测量长距离的场景，如航空航线计算。
特点: 计算出的距离是沿着地球表面的大圆（球面）路径的最短距离。

用法:

distance(startPoint, endPoint, options?)

参数:

startPoint (Coord | Point): 开始的点
endPoint (Coord | Point): 结束的点
options? ({units?: string}): units距离单位: degrees度、radians弧度、miles英里、kilometers公里（kilometers）

返回:

(Number): 两点之间的距离

例子:

var from = turf.point([-75.343, 39.984]);
var to = turf.point([-75.534, 39.123]);
var options = { units: "miles" };

var distance = turf.distance(from, to, options); // 60.35329997171415

rhumbDistance 两点之间的投影最短距离

计算两点在固定方向角上的距离，返回的是绝对值。也就是说在地图投影上时一条直线（distance会是一条曲线。但在地球上曲线比直线更短）

计算方法: rhumbDistance 函数使用的是恒向线距离（Rhumb line distance），这是一种在地图上沿着固定方位角（恒定的方向）行进的路径。
适用场景: 恒向线距离适用于需要沿固定方向移动的场景，如航海和飞行导航，因为这种路径保持了方位角的一致性。它特别适用于中短距离的场景，或者在地图投影中保持直线的情况下。
特点: 计算出的距离是沿着地图上直线的距离，但这条路径通常不是大圆距离的最短路径。

用法:

rhumbDistance(startPoint, endPoint, options?)

参数:

startPoint (Coord): 原点
endPoint (Coord): 结束点
options? ({units?: string}): units距离单位, degrees度、radians弧度、miles英里、kilometers公里(默认是千米)

返回:

(Number): 两点之间的距离。的绝对值

例子:

var from = turf.point([-75.343, 39.984]);
var to = turf.point([-75.534, 39.123]);
var options = { units: "miles" };

var distance = turf.rhumbDistance(from, to, options); // 60.35331130430885

nearestPoint 获取一个点集合中，离某个目标最近的点

获取一个点集合中，离某个目标的最近的点

用法：

nearestPoint(targetPoint, points, options?)

参数:

targetPoint (Coord): 参考的目标点
points (FeatureCollection<Point>): 点集合
options.？units？ (string): 数值结果的单位

返回：

(Feature)

例子：

var targetPoint = turf.point([28.965797, 41.010086], {
  "marker-color": "#0F0",
});
var points = turf.featureCollection([
  turf.point([28.973865, 41.011122]),
  turf.point([28.948459, 41.024204]),
  turf.point([28.938674, 41.013324]),
]);

var nearest = turf.nearestPoint(targetPoint, points);

greatCircle 生成两点之间的大圆航线

计算大圆航线，表示为LineString或MultiLineString。如果start和end点跨越本初子午线，生成的要素将被分割为一个MultiLineString。

用法:

greatCircle(startPoint, endPoint, options?)

参数:

startPoint (Coord): 开始的点
endPoint (Coord): 结束的点
options?.properties? (Object): 赋值到返回的LineString对象上properties
options?.npoints? (Number): 大圆航线上的点数，默认是100
options?.offset? (Number): offset controls the likelyhood that lines will be split which cross the dateline. The higher the number the more likely. (default 10)

返回:

(Feature<LineString | MultiLineString>): 大圆航线

例子:

var start = turf.point([-122, 48]);
var end = turf.point([-77, 39]);

var greatCircle = turf.greatCircle(start, end, {
  properties: { name: "Seattle to DC" },
});

midpoint 计算两点之间的中点

接受两个点，并返回它们之间的中点。中点是通过大地测量计算的，意味着考虑了地球的曲率。

用法:

midpoint(startPoint, endPoint?)

参数:

startPoint (Coord): 开始的点
endPoint (Coord): 结束的点

返回:

(Feature<Point>): 中点

例子:

var point1 = turf.point([144.834823, -37.771257]);
var point2 = turf.point([145.14244, -37.830937]);

var midpoint = turf.midpoint(point1, point2);

shortestPath 计算两点间的最短路径并自动避开障碍物

返回起点到终点的最短路径，并自动避开障碍物（obstacles）

用法：

shortestPath(start, stop, options?)

参数:

start (Feature<Point>): 起点
stop (Feature<Point>): 终点
options?.obstacles? (Geometry | Feature | FeatureCollection<Polygon>): 障碍物(路径无法通过的区域)
options?.units? (string): 单位，默认'kilometers'
options?.resolution? (number): 计算路径上顶点间的距离，默认100

返回：

(Feature)

例子：

var start = [-5, -6];
var end = [9, -6];
var options = {
  obstacles: turf.polygon([
    [
      [0, -7],
      [5, -7],
      [5, -3],
      [0, -3],
      [0, -7],
    ],
  ]),
};

var path = turf.shortestPath(start, end, options);

angle 计算一个点伸出的两条线的夹角

输入三个点，中点-起点为开始线，中点-终点为结束线。计算他们的顺时针夹角

用法：

angle(startPoint, midPoint, endPoint, options?)

参数:

startPoint (Coord): 开始点坐标
midPoint (Coord): 中点坐标
endPoint (Coord): 结束点坐标
options.explementary? (boolean): 结果返回补角（360 - angle）默认 false
options.mercator? (boolean): 是否用墨卡托投影计算，默认false,用真实地理线计算（真实地理线是弧形）

返回：

(number)

例子：

turf.angle([5, 5], [5, 6], [3, 4]);
//=45

三.Coordinate Mutation 坐标变换 & Unit Conversion 单位转换

toMercator 经纬度转墨卡托

转换经纬度 WGS84 为墨卡托 Mercator(EPSG:900913)

用法：

toMercator(geojson, options)

参数:

geojson (GeoJSON | Position): 经纬度对象
options?.mutate? (boolean): 是否直接在输入的GeoJSON对象上修改,如果为true,则性能显著提高 default false

返回：

(GeoJSON)

例子：

var pt = turf.point([-71, 41]);
var converted = turf.toMercator(pt);

toWgs84 墨卡托转经纬度

转换墨卡托 Mercator(EPSG:900913) 为经纬度 WGS84

用法：

toWgs84(geojson, options)

参数:

geojson (GeoJSON | Position): 墨卡托对象
options?.mutate? (boolean): 是否直接在输入的GeoJSON对象上修改,如果为true,则性能显著提高 default false

返回：

(GeoJSON)

例子：

var pt = turf.point([-7903683.846322424, 5012341.663847514]);
var converted = turf.toWgs84(pt);

cleanCoords 删除冗余坐标

从任何 GeoJSON 几何体中删除冗余坐标。例如连续两个点是一模一样的坐标就删除一个。如果是线。一条直线上有连续多个点。删除中间的点。

用法:

cleanCoords(geojson, options?)

参数:

geojson (Geometry | Feature): 几何体
options? ({mutate?: boolean}): mutate为true时，直接在原对象上修改

返回:

(Geometry | Feature): 删除冗余坐标后的几何体

例子：

var line = turf.lineString([
  [0, 0],
  [0, 2],
  [0, 5],
  [0, 8],
  [0, 8],
  [0, 10],
]);
var multiPoint = turf.multiPoint([
  [0, 0],
  [0, 0],
  [2, 2],
]);

turf.cleanCoords(line).geometry.coordinates;
//= [[0, 0], [0, 10]]

turf.cleanCoords(multiPoint).geometry.coordinates;
//= [[0, 0], [2, 2]]

flip 翻转坐标

接受输入要素，并将它们所有的坐标从 [x, y] 翻转为 [y, x]。

用法:

flip(geojson, options?)

参数:

geojson (Geometry): 几何体
options? ({mutate?: boolean}): mutate为true时，直接在原对象上修改

返回：

(Geometry): 翻转过坐标后的对象

例子：

var serbia = turf.point([20.566406, 43.421008]);

var saudiArabia = turf.flip(serbia.geometry.coordinates); //  [43.421008, 20.566406]

rewind 逆时针重绕

逆时针重绕 (Multi)LineString 或 (Multi)Polygon 的外环，内环顺时针（使用鞋带公式）。

用法:

rewind(geojson, options?)

参数:

geojson (Geometry): 几何体
options? ({reverse?: boolean, mutate?: boolean}): reverse为true时，反向翻转。 mutate为true时，直接在原对象上修改

返回：

(Geometry): 逆时针重绕后的对象

例子：

var polygon = turf.polygon([
  [
    [121, -29],
    [138, -29],
    [138, -18],
    [121, -18],
    [121, -29],
  ],
]);

var rewind = turf.rewind(polygon);

round 四舍五入

将数字四舍五入到指定精度。

用法：

round(value, precision)

参数:

value (number): 输入的值
precision? (number): 精度

例子：

turf.round(120.4321);
//=120

turf.round(120.4321, 2);
//=120.43

truncate 截取精度

接受一个 GeoJSON 要素或要素集合，并截断几何形状的精度。

用法：

truncate(geojson, options?)

参数:

geojson (Geometry): 几何体
options? ({precision?: number, coordinates?: number, mutate?: boolean}): precision坐标进度(默认6); 最多的坐标数量(主要用来抹去z轴坐标，默认是3,既x\y\z坐标都有) mutate为true时，直接在原对象上修改

返回：

(Geometry): 几何体

例子：

var point = turf.point([70.46923055566859, 58.11088890802906, 1508]);
var options = { precision: 3, coordinates: 2 };
var truncated = turf.truncate(point, options);
//=truncated.geometry.coordinates => [70.469, 58.111]

bearingToAzimuth (-180 ~ 180)度转为(0 ~ 360)度

把方位角(-180 ~ 180)度(北向线顺时针为正，逆时针为负)转为(0 ~ 360)度(北向线顺时针计算值)

用法：

bearingToAzimuth(bearing)

参数:

bearing (number): (-180 ~ 180)

返回：

(number) (0 ~ 360)

例子：

convertArea 面积单位转换

面积单位转换，有效单位：kilometers, kilometres, meters, metres, centimetres, millimeters, acres, miles, yards, feet, inches, hectares

用法：

convertArea(area, originalUnit?, finalUnit?)

参数:

area (number): 需要转换的面积
originalUnit (Units): default "meters"
finalUnit (Units): default "kilometers"

返回：

(number)

例子：

convertLength 长度单位转换

长度单位转换，有效单位：miles, nauticalmiles, inches, yards, meters, metres, kilometers, centimeters, feet

用法：

convertLength(length, originalUnit?, finalUnit?)

参数:

length (number): 需要转换的长度
originalUnit (Units): default "meters"
finalUnit (Units): default "kilometers"

返回：

(number)

例子：

degreesToRadians 度转换为弧度

将角度(以度为单位)转换为弧度

用法：

degreesToRadians(degrees)

参数:

degrees (number): 度

返回：

(number) 弧度

例子：

radiansToDegrees 弧度转为度

lengthToDegrees 地球面上的距离长度转为度数

地球面上的距离长度转为度数,有效单位：miles, nauticalmiles, inches, yards, meters, metres, centimeters, kilometres, feet

用法：

lengthToDegrees(distance, units?)

参数:

distance (number): 现实中的距离
units? (string): 距离单位，默认千米

返回：

(number) 度数

例子：

lengthToRadians 地球面上的距离长度转为弧度

radiansToLength 弧度转为地球面上的距离长度

四.Transformation 变换

bboxClip 根据边界框裁切要素

将一个要素和一个边界框（bbox）作为输入，使用lineclip将要素裁剪到边界框。在裁剪多边形时可能会产生退化边缘（即如果多边形都不在范围内，裁剪结果时空）。

用法：

bboxClip(geojson, bbox)

参数:

geojson (Geometry): 几何体
bbox (BBox): extent in [minX, minY, maxX, maxY] order

返回：

Feature<LineString | MultiLineString | Polygon | MultiPolygon> 裁剪后的要素

例子：

var bbox = [0, 0, 10, 10];
var poly = turf.polygon([
  [
    [2, 2],
    [8, 4],
    [12, 8],
    [3, 7],
    [2, 2],
  ],
]);

var clipped = turf.bboxClip(poly, bbox);

bezierSpline 把线转为赛贝尔曲线

接受一条线并通过应用Bezier样条算法返回曲线版本。这个Bezier样条的实现是由Leszek Rybicki完成的。

用法：

bezierSpline(line, options?)

参数:

line (Feature<LineString>): 线对象
options? ({properties?: Object, resolution?: number, sharpness?: number}):
options.resolution: time in milliseconds between points (default 10000);
options.sharpness: time in milliseconds between points (default 10000);

返回：

(Feature) 曲线

例子：

var line = turf.lineString([
  [-76.091308, 18.427501],
  [-76.695556, 18.729501],
  [-76.552734, 19.40443],
  [-74.61914, 19.134789],
  [-73.652343, 20.07657],
  [-73.157958, 20.210656],
]);

var curved = turf.bezierSpline(line);

difference 对比差异(差集)

通过从第一个多边形中剪切后续多边形来找到多个polygons之间的差异。也就是第一个要素中有。后续要素中没有的部分

用法：

difference(features)

参数:

features (FeatureCollection<Polygon | MultiPolygon>): 要素集合

返回：

(Feature<Polygon | MultiPolygon> | null) 差异部分的集合

例子：

var polygon1 = turf.polygon(
  [
    [
      [128, -26],
      [141, -26],
      [141, -21],
      [128, -21],
      [128, -26],
    ],
  ],
  {
    fill: "#F00",
    "fill-opacity": 0.1,
  },
);
var polygon2 = turf.polygon(
  [
    [
      [126, -28],
      [140, -28],
      [140, -20],
      [126, -20],
      [126, -28],
    ],
  ],intersection
  {
    fill: "#00F",
    "fill-opacity": 0.1,
  },
);

var difference = turf.difference(turf.featureCollection([polygon1, polygon2]));

中间橙色部分是第一集合。蓝色部分是第二集合。右边凸出的那一块就是差异集合

intersect 交集

接受polygon或multi-polygon几何体，并找到它们的多边形交集。如果它们不相交，则返回空值

用法：

intersect(features, options?)

参数:

features (FeatureCollection<Polygon | MultiPolygon>): 要素集合
options ({options?: {properties?: Object}}):

返回：

(Feature | null) 交集部分的要素集合

例子：

var poly1 = turf.polygon([
  [
    [-122.801742, 45.48565],
    [-122.801742, 45.60491],
    [-122.584762, 45.60491],
    [-122.584762, 45.48565],
    [-122.801742, 45.48565],
  ],
]);

var poly2 = turf.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 intersection = turf.intersect(turf.featureCollection([poly1, poly2]));

中间深色部分就是并集区域

dissolve 要素融合

对一个包含多个polygon特征的FeatureCollection进行融合，可以选择根据可选的属性名称：值进行过滤。请注意，该集合中的multipolygon特征不受支持。

用法：

dissolve(featureCollection, options?)

参数:

featureCollection (FeatureCollection<Polygon>): 需要融合的要素集合
options? ({propertyName?: string}): propertyName: 要素中拥有相同propertyName值的要素会被融合

返回：

(FeatureCollection) 融合后的要素集合

例子：

var features = turf.featureCollection([
  turf.polygon(
    [
      [
        [0, 0],
        [0, 1],
        [1, 1],
        [1, 0],
        [0, 0],
      ],
    ],
    { combine: "yes" },
  ),
  turf.polygon(
    [
      [
        [0, -1],
        [0, 0],
        [1, 0],
        [1, -1],
        [0, -1],
      ],
    ],
    { combine: "yes" },
  ),
  turf.polygon(
    [
      [
        [1, -1],
        [1, 0],
        [2, 0],
        [2, -1],
        [1, -1],
      ],
    ],
    { combine: "no" },
  ),
]);

var dissolved = turf.dissolve(features, { propertyName: "combine" });
// 内部包含两个Feature

lineOffset 线偏移(沿着线的法线方向)

接受一条line，并返回一个以指定距离偏移的line。

用法：

lineOffset(geojson, distance, options?)

参数:

geojson (Geometry | Feature<LineString | MultiLineString>): 线的集合
distance (number): 偏移的距离，可以是负值
options? ({units: string}): units 单位

返回：

(Feature<LineString | MultiLineString>) 返回偏移后的线

例子：

var line = turf.lineString(
  [
    [-83, 30],
    [-84, 36],
    [-78, 41],
  ],
  { stroke: "#F00" },
);

var offsetLine = turf.lineOffset(line, 200, { units: "miles" });

polygonSmooth 多边形平滑处理

对一个Polygon或MultiPolygon进行平滑处理。基于Chaikin's algorithm。警告：可能会创建退化的多边形。

用法：

polygonSmooth(geojson, options)

参数:

geojson (FeatureCollection<Polygon | MultiPolygon> | Feature<Polygon | MultiPolygon> | Polygon | MultiPolygon): 多边形几何体
options? ({iterations: number}): iterations 平滑多边形的次数，值越高，越平滑（默认1）

返回：

(FeatureCollection<Polygon | MultiPolygon>) 平滑后的多边形要素

例子：

var polygon = turf.polygon([
  [
    [11, 0],
    [22, 4],
    [31, 0],
    [31, 11],
    [21, 15],
    [11, 11],
    [11, 0],
  ],
]);

var smoothed = turf.polygonSmooth(polygon, { iterations: 3 });

simplify 简化多边形

接受一个GeoJSON对象，并返回一个简化版本。在内部使用simplify-js的二维版本，使用Ramer-Douglas-Peucker算法执行简化。

用于对 GeoJSON 对象进行几何简化，即减少其点数，同时尽量保持其形状和特征的准确性。简化后的几何对象具有更少的顶点，这在需要提高渲染性能、减少数据量，或在进行数据传输时非常有用。
通过减少多边形、线条或其他几何对象的顶点数量来简化其形状。这种简化可以在不显著改变几何特征的前提下，使复杂的几何对象更易于处理和显示。

用法：

simplify(geojson, options?)

参数:

geojson (Geometry): 几何体
options? ({tolerance?: number, highQuality?: boolean, mutate?: boolean}): 几何体
options.tolerance 简化程度的容差值,它控制简化的力度。较高的容差值会大幅减少顶点数量，从而简化形状，但可能会失去更多细节。较低的容差值则保留更多的细节。默认（1）
options.highQuality 是否花更多的时间用不同的算法生成更高质量的简化效果
options.mutate 是否直接在输入的对象上更改

返回：

(GeoJSON) 简化后的地理数据

例子：

var geojson = turf.polygon([
  [
    [-70.603637, -33.399918],
    [-70.614624, -33.395332],
    [-70.639343, -33.392466],
    [-70.659942, -33.394759],
    [-70.683975, -33.404504],
    [-70.697021, -33.419406],
    [-70.701141, -33.434306],
    [-70.700454, -33.446339],
    [-70.694274, -33.458369],
    [-70.682601, -33.465816],
    [-70.668869, -33.472117],
    [-70.646209, -33.473835],
    [-70.624923, -33.472117],
    [-70.609817, -33.468107],
    [-70.595397, -33.458369],
    [-70.587158, -33.442901],
    [-70.587158, -33.426283],
    [-70.590591, -33.414248],
    [-70.594711, -33.406224],
    [-70.603637, -33.399918],
  ],
]);
var options = { tolerance: 0.01, highQuality: false };
var simplified = turf.simplify(geojson, options);

tesselate 多边形的三角剖分

将一个 Feature 进行三角剖分，生成一个由三角形组成的 FeatureCollection，使用 earcut 进行操作。

用法：

tesselate(geojson)

参数:

geojson (Feature<Polygon>): 多边形几何体

返回：

(FeatureCollection) 又三角形组成的多边形集合

例子：

var poly = turf.polygon([
  [
    [11, 0],
    [22, 4],
    [31, 0],
    [31, 11],
    [21, 15],
    [11, 11],
    [11, 0],
  ],
]);
var triangles = turf.tesselate(poly);

transformRotate 旋转

旋转任何指定角度的 GeoJSON Feature 或 Geometry，围绕其 centroid(质心) 或给定的 pivot 点进行旋转。

用法：

transformRotate(geojson, angle, options?)

参数:

geojson (GeoJSON): 几何体
angle (number): 旋转角度
options? ({pivot?: Coord, mutate?: boolean}): pivot 旋转的中心点；mutate 是否直接在输入的对象上改

返回：

(GeoJSON)

例子：

var poly = turf.polygon([
  [
    [0, 29],
    [3.5, 29],
    [2.5, 32],
    [0, 29],
  ],
]);
var options = { pivot: [0, 25] };
var rotatedPoly = turf.transformRotate(poly, 10, options);

transformScale 缩放

根据给定点和缩放因子对 GeoJSON 进行缩放（例如，factor=2 将使 GeoJSON 变大200%）。如果提供了 FeatureCollection，则原点将基于每个单独的 Feature 进行计算。

用法：

transformScale(geojson, factor, options)

参数:

geojson (GeoJSON): 几何体
factor (number): 放大倍数，必须大于0， 0~1是缩小，>1是放大
options? ({origin?: string | Coord, mutate?: boolean}): origin 缩放的的中心点(string opitons: w/se/nw/ne/center/centroid (default 'centroid'))；mutate 是否直接在输入的对象上改

返回：

(GeoJSON)

例子：

var poly = turf.polygon([
  [
    [0, 29],
    [3.5, 29],
    [2.5, 32],
    [0, 29],
  ],
]);
var scaledPoly = turf.transformScale(poly, 3);

transformTranslate 平移

沿着提供的方向角，在指定距离上沿着一条恒向线(投影线)移动任何 GeoJSON Feature 或 Geometry。

用法：

transformTranslate(geojson, distance, direction, options?)

参数:

geojson (GeoJSON): 几何体
distance (number): 平移的距离
direction (number): 平移的方向，和正北方的夹角的度数。顺时针为正
options ({units?: string, zTranslation?: number, mutate?: boolean}): units 单位；zTranslation 猜测为z轴(垂直于地图)方向上的移动距离；mutate 是否直接在输入的对象上改

返回：

(GeoJSON)

例子：

var poly = turf.polygon([
  [
    [0, 29],
    [3.5, 29],
    [2.5, 32],
    [0, 29],
  ],
]);
var translatedPoly = turf.transformTranslate(poly, 100, 35);

union 合并(并集)

接受输入的 (多)多边形，并返回一个合并后的多边形。如果输入的多边形不是连续的，此函数将返回一个 MultiPolygon 特征。

用法：

union(features, options?)

参数:

features (FeatureCollection<Polygon | MultiPolygon>): 几何体
options ({properties?: Object})

返回：

()

例子：

Voronoi 每一个点都单独包围起来

接受一个点的 FeatureCollection 和一个边界框，并返回一个 Voronoi 多边形的 FeatureCollection。使用的 Voronoi 算法来自 d3-voronoi 包。

用法：

voronoi(points, options)

参数:

points (FeatureCollection<Point>): 点的集合
options ({bbox?: Array<number>}) 裁剪的矩形区域[minX, minY, maxX, MaxY]. (default [-180,-85,180,-85])

返回：

(FeatureCollection)

例子：

var options = {
  bbox: [-70, 40, -60, 60],
};
var points = turf.randomPoint(100, options);
var voronoiPolygons = turf.voronoi(points, options);

kinks 线、多边形自交点

获取 linestring, multi-linestring, multi-polygon or polygon 的自交点集合

用法：

kinks(featureIn)

参数:

featureIn (Feature<LineString | MultiLineString | MultiPolygon | Polygon>): 输入要素

返回：

(FeatureCollection) 自交点集合

例子：

var poly = turf.polygon([
  [
    [-12.034835, 8.901183],
    [-12.060413, 8.899826],
    [-12.03638, 8.873199],
    [-12.059383, 8.871418],
    [-12.034835, 8.901183],
  ],
]);

var kinks = turf.kinks(poly);

kinks

lineIntersect 线、多边形相交点

获取任意线与多边形的交点

用法：

lineIntersect(line1, line2, options?)

参数:

line1 (GeoJSON): any LineString or Polygon
line2 (GeoJSON): any LineString or Polygon
options?.removeDuplicates? (boolean): 是否移除重复的点默认 true
options?.ignoreSelfIntersections? (boolean): 是否忽略自相交默认 false

返回：

(FeatureCollection)

例子：

var line1 = turf.lineString([
  [126, -11],
  [129, -21],
]);
var line2 = turf.lineString([
  [123, -18],
  [131, -14],
]);
var intersects = turf.lineIntersect(line1, line2);

lineOverlap 获取重叠的线

接受LineString或MultiLineString，并返回一个包含所有重叠线段的FeatureCollection

用法：

lineOverlap(line1, line2, options?)

参数:

line1 (Geometry | Feature<LineString | MultiLineString | Polygon | MultiPolygon>): 线
line2 (Geometry | Feature<LineString | MultiLineString | Polygon | MultiPolygon>): 线
options?.tolerance? (number): 容差距离， (in kilometers) (default 0)

返回：

(FeatureCollection) 重叠部分的管道

例子：

var line1 = turf.lineString([
  [115, -35],
  [125, -30],
  [135, -30],
  [145, -35],
]);
var line2 = turf.lineString([
  [115, -25],
  [125, -30],
  [135, -30],
  [145, -25],
]);

var overlapping = turf.lineOverlap(line1, line2);

五.Feature Conversion 要素转换

combine 联合

合并一个要素集合（eg. Point, LineString, Polygon）为（eg.MultiPoint, MultiLineString, MultiPolygon）

用法：

combine(geojson)

参数:

geojson (FeatureCollection<Point | LineString | Polygon>): 几何体

返回：

(FeatureCollection<MultiPoint | MultiLineString | MultiPolygon>)

例子：

var fc = turf.featureCollection([
  turf.point([19.026432, 47.49134]),
  turf.point([19.074497, 47.509548]),
]);

var combined = turf.combine(fc)
// -------
var fc = turf.featureCollection([
  turf.point([19.026432, 47.49134]),
  turf.point([19.074497, 47.509548]),
	turf.lineString([
    [-24, 63],
    [-23, 60],
    [-25, 65],
    [-20, 69],
  ])
]);

var combined = turf.combine(fc);

explode 获取所有坐标点

接受一个要素或一组要素，并将所有位置作为点返回。

用法：

explode(geojson)

参数:

geojson (GeoJSON): 几何体

返回：

(FeatureCollection)

例子：

var polygon = turf.polygon([
  [
    [-81, 41],
    [-88, 36],
    [-84, 31],
    [-80, 33],
    [-77, 39],
    [-81, 41],
  ],
]);

var explode = turf.explode(polygon);

flatten 扁平化

扁平化任何的GeoJSON对象为一个FeatureCollection,启发与geojon-flatten包

用法：

flatten(geojson)

参数:

geojson (GeoJSON): 几何体

返回：

(FeatureCollection)

例子：

var multiGeometry = turf.multiPolygon([
  [
    [
      [102.0, 2.0],
      [103.0, 2.0],
      [103.0, 3.0],
      [102.0, 3.0],
      [102.0, 2.0],
    ],
  ],
  [
    [
      [100.0, 0.0],
      [101.0, 0.0],
      [101.0, 1.0],
      [100.0, 1.0],
      [100.0, 0.0],
    ],
    [
      [100.2, 0.2],
      [100.8, 0.2],
      [100.8, 0.8],
      [100.2, 0.8],
      [100.2, 0.2],
    ],
  ],
]);

var flatten = turf.flatten(multiGeometry); // 变成两个 Polygon

lineToPolygon 线转多边形

转换(Multi)LineString(s)为(Multi)Polygon(s)

用法：

lineToPolygon(lines, options?)

参数:

lines (FeatureCollection | Feature<LineString | MultiLineString>): 几何体
options?.properties (Object): 属性
options?.autoComplete (boolean): 是否自动闭合(把线的终点和起点连起来，默认true)
options?.orderCoords (boolean): 是否应该对输入的线段坐标进行排序，以确保它们按顺序连接形成一个闭合的多边形，默认true.如果线段坐标顺序不正确，此参数可以帮助修正它们。
options?.mutate (boolean): 是否直接在输入的对象上改默认 false

返回：

(Feature<Polygon | MultiPolygon>)

例子：

var line = turf.lineString([
  [125, -30],
  [145, -30],
  [145, -20],
  [125, -20],
  [125, -30],
]);

var polygon = turf.lineToPolygon(line);

polygonToLine 多边形转线

转换一个Polygon为(Multi)LineString 或转换 MultiPolygon 为 (Multi)LineString

用法：

polygonToLine(poly)

参数:

poly (Feature<Polygon | MultiPolygon>): 多边形几何体
options?.properties (Object): 属性

返回：

(FeatureCollection | Feature<LineString | MultiLineString>)

例子：

var poly = turf.polygon([
  [
    [125, -30],
    [145, -30],
    [145, -20],
    [125, -20],
    [125, -30],
  ],
]);

var line = turf.polygonToLine(poly);

polygonize 将多线段转为多边形

Polygonizes (Multi)LineString(s) into Polygons.

Implementation of GEOSPolygonize function (geos::operation::polygonize::Polygonizer).

Polygonizes a set of lines that represents edges in a planar graph. Edges must be correctly noded, i.e., they must only meet at their endpoints.

The implementation correctly handles:

Dangles: edges which have one or both ends which are not incident on another edge endpoint.
Cut Edges (bridges): edges that are connected at both ends but which do not form part of a polygon.

用法：

polygonize(geojson)

参数:

geojson (FeatureCollection | Geometry | Feature<LineString | MultiLineString): Lines in order to polygonize

返回：

(FeatureCollection)

例子：

七. 生成数据

geometry 生成一个几何图形

根据类型和坐标生成一个几何图形

用法：

geometry(type, coord, options?)

参数:

type (string): 几何体类型
coord (Array<any>): 几何坐标
options? (Object): 可选参数

返回：

(Geometry)

例子：

var type = "Point";
var coordinates = [110, 50];
var geometry = turf.geometry(type, coordinates);
// => geometry

geometryCollection 几何集合

基于坐标数组创建一个Feature

用法：

geometryCollection(geometries, properties? options?)

参数:

geometries (Array<Geometry>): 几何体数组
properties? (Object): 属性
options?.bbox? (Array<number>): [west, south, east, north]
options?.id? (string): 要素的ID

返回：

(Feature)

例子：

var pt = turf.geometry("Point", [100, 0]);
var line = turf.geometry("LineString", [
  [101, 0],
  [102, 1],
]);
var collection = turf.geometryCollection([pt, line]);

// => collection

getGeom 获取Geometry对象

从Feature or Geometry Object中获取Geometry对象

用法：

getGeom(geojson)

参数:

geojson (Feature | Geometry): 几何体

返回：

(Geometry | null)

例子：

var point = {
  type: "Feature",
  properties: {},
  geometry: {
    type: "Point",
    coordinates: [110, 40],
  },
};
var geom = turf.getGeom(point);
//={"type": "Point", "coordinates": [110, 40]}

point 根据坐标生成点要素

根据坐标生成点要素

用法：

point(coordinates, properties?, options?)

参数:

coordinates ([number, number]): 坐标（longitude 经度, latitude 纬度）
properties? (Object): 属性
options?.bbox? (Array<number>): [west, south, east, north]
options?.id? (string): 要素的ID

返回：

(Feature)

例子：

var point = turf.point([-75.343, 39.984]);

//=point

multiPoint 根据坐标数组生成多点要素

根据坐标数组生成多点要素

用法：

multiPoint(coordinates, properties?, options?)

参数:

coordinates (Array<[number, number]>): 坐标数组
properties? (Object): 属性
options?.bbox? (Array<number>): [west, south, east, north]
options?.id? (string): 要素的ID

返回：

(Feature)

例子：

var multiPt = turf.multiPoint([
  [0, 0],
  [10, 10],
]);

//=multiPt

points 生成点要素集合

从点坐标数组创建点要素集合

用法：

points(coord, properties, options?)

参数:

coord (Array<Array<number>>): 一组点坐标
properties? (Object): 每一个要素的属性
options.bbox? (Array<number>):
options.id? (string | number):

返回：

(FeatureCollection<Point>)

例子：

var points = turf.points([
  [-75, 39],
  [-80, 45],
  [-78, 50],
]);

//=points

lineString 根据坐标生成线要素

根据一组点位生成线要素

用法：

lineString(coordinates, properties?, options?)

参数:

coordinates (Array<[number, number]>): 坐标数组
properties? (Object): 属性
options?.bbox? (Array<number>): [west, south, east, north]
options?.id? (string): 要素的ID

返回：

(Feature)

例子：

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

multiLineString 根据坐标生成多线要素

根据一组坐标数组生成多线要素

用法：

multiLineString(coordinates, properties?, options?)

参数:

coordinates (Array<Array<[number, number]>>): 坐标数组
properties? (Object): 属性
options?.bbox? (Array<number>): [west, south, east, north]
options?.id? (string): 要素的ID

返回：

(Feature)

例子：

var multiLine = turf.multiLineString([
  [
    [0, 0],
    [10, 10],
  ],
]);

//=multiLine

polygon 根据一组首尾相连的坐标生成多边形要素

根据一组首尾相连的坐标生成多边形要素

用法：

polygon(coordinates, properties?, options?)

参数:

coordinates (Array<Array<[number, number]>>): 坐标数组
properties? (Object): 属性
options?.bbox? (Array<number>): [west, south, east, north]
options?.id? (string): 要素的ID

返回：

(Feature)

例子：

var polygon = turf.polygon(
  [
    [
      [-5, 52],
      [-4, 56],
      [-2, 51],
      [-7, 54],
      [-5, 52],
    ],
  ],
  { name: "poly1" },
);

//=polygon

multiPolygon 生成多组多边形要素

生成多组多边形要素

用法：

multiPolygon(coordinates, properties?, options?)

参数:

coordinates (Array<Array<Array<[number, number]>>>): 坐标数组
properties? (Object): 属性
options?.bbox? (Array<number>): [west, south, east, north]
options?.id? (string): 要素的ID

返回：

(Feature)

例子：

var multiPoly = turf.multiPolygon([
  [
    [
      [0, 0],
      [0, 10],
      [10, 10],
      [10, 0],
      [0, 0],
    ],
  ],
]);

//=multiPoly

polygons 生成一个多边形要素集合

从一组多边形坐标中创建多边形要素集合

用法：

polygons(coord, properties, options?)

参数:

coord (Array<Array<Array<Array<number>>>>): 一组坐标
- properties? (Object): 每一个要素的属性
options.bbox? (Array<number>):
options.id? (string | number):

返回：

(FeatureCollection<Polygon>)

例子：

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

feature 根据几何体(Geometry)生成要素

将GeoJSON图形包裹在一个GeoJSON要素中

用法：

feature(geometry, properties?, options?)

参数:

geometry (Geometry): 几何体
properties? (Object): 属性
options?.bbox? (Array<number>): [west, south, east, north]
options?.id? (string): 要素的ID

返回：

(Feature)

例子：

var geometry = {
  type: "Point",
  coordinates: [110, 50],
};

var feature = turf.feature(geometry);

//=feature

featureCollection 根据要素(Feature)生成要素集合

接收一个或多个要素，返回要素集合

用法：

featureCollection(features, options?)

参数:

features (Array<Feature>): 要素
options?.bbox? (Array<number>): [west, south, east, north]
options?.id? (string): 要素的ID

返回：

(FeatureCollection)

例子：

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

circle 根据点和半径计算圆

接受一个Point，根据给定的半径（以度degrees、弧度radians、英里miles或公里kilometers表示）和精度步长，计算圆形多边形。

用法：

circle(center, radius, options?)

参数:

center (Feature<Point> | Array<number>): 中心点
radius (number): 半径
options? ({steps?: number, units?: string, properties?: Object}): steps精度步长；units单位

返回：

(Feature) 范围要素

例子：

var center = [-75.343, 39.984];
var radius = 5;
var options = { steps: 10, units: "kilometers", properties: { foo: "bar" } };
var circle = turf.circle(center, radius, options);

ellipse 生成一个椭圆

生成一个椭圆

用法：

ellipse(center, xSemiAxis, ySemiAxis, options?)

参数:

center (Coord): 中心点
xSemiAxis (number): x轴半径
ySemiAxis (number): y轴半径
options.angle? (number): 旋转角度
options.pivot? (Coord): 旋转的中心点（默认用center）
options.steps? (number): 精度 64
options.units? (string): 半径单位默认千米
options.properties? (Coord): 属性

返回：

(Feature<Polygon>)

例子：

var center = [-75, 40];
var xSemiAxis = 5;
var ySemiAxis = 2;
var ellipse = turf.ellipse(center, xSemiAxis, ySemiAxis);

lineArc 生成弧线

生成一条弧线，根据圆心、半径、开始方位、结束方位.(0度为正北，顺时针为正方向)

用法：

lineArc(center, radius, bearing1, bearing2, options?)

参数:

center (Coord): 圆的中心点
radius (number): 半径
bearing1 (number): 开始方位
bearing2 (number): 结束方位
options?.steps? (number): 步长，值越大，圆弧越平滑，默认64
options?.units? (string): 角度单位，默认'kilometers'

返回：

(Feature)

例子：

var center = turf.point([-75, 40]);
var radius = 5;
var bearing1 = 25;
var bearing2 = 47;

var arc = turf.lineArc(center, radius, bearing1, bearing2);

sector 生成扇形

生成一个扇形或圆；需要提供圆心、半径、开始方位、结束方位。(0度为正北，顺时针为正方向)

用法：

sector(center, radius, bearing1, bearing2, options?)

参数:

center (Coord): 圆心
radius (number): 半径
bearing1 (number): 开始方位
bearing2 (number): 结束方位
options?.steps? (number): 步长，值越大，圆弧越平滑，默认64
options?.units? (string): 角度单位，默认'kilometers'
options?.properties? (Object): 属性

返回：

(Feature)

例子：

var center = turf.point([-75, 40]);
var radius = 5;
var bearing1 = 25;
var bearing2 = 45;

var sector = turf.sector(center, radius, bearing1, bearing2);

buffer 缓冲区(扩散/影响区)

用于在 GeoJSON 对象周围创建一个缓冲区（buffer zone）。这个缓冲区可以看作是围绕一个几何对象的一定范围的扩展区域，通常用于分析距离、影响范围或安全区域等地理问题。

buffer 函数能够为点、线、多边形等几何对象生成指定距离的缓冲区。这些缓冲区通常用于分析周围区域受几何对象影响的范围，比如交通影响区、安全缓冲区等。

用法：

buffer(geojson, radius, options?)

参数:

geojson (Geometry): 几何体
radius (number): 缓冲半径，可以为正值（向外扩展）或负值（向内收缩）
options ({units?: string, steps?: number}): units 单位， steps 定义生成的多边形的平滑度，即多边形圆角的细化程度(默认8)，值越高，生成的多边形边缘越平滑，但计算也更复杂。

返回：

(FeatureCollection | Feature<Polygon | MultiPolygon> | undefined) 缓冲区范围要素

例子：

var point = turf.point([-90.54863, 14.616599]);
var buffered = turf.buffer(point, 500, { units: "miles" });

concave 生成凹多边形范围

接受一组点，并返回一个凹多边形（Polygon）或多部分凹多边形（MultiPolygon）。在内部，这使用turf-tin来生成几何图形。

特点: 凹多边形可能包含“凹入”的部分，即多边形的某些边可能向内部弯曲。生成的多边形会尽量贴近输入点的分布，形成更加精确的外形。（但如果没有凹进去的点，那也就会不凹）
适用场景: 当你希望生成的多边形紧密包围一组散布的点，且保留一些凹入特征时，使用 concave。例如，在地理分析中，你可能需要描绘实际边界或轮廓。

用法：

concave(points, options?)

参数:

points (FeatureCollection<Point>): 输入的点集合
options ({maxEdge?: number, units?: string}): maxEdge 边缘最大长度。值越小，精度越高。默认是（Infinity）,units单位

返回：

(Feature<Polygon | MultiPolygon> | null) 返回的范围

例子：

var points = turf.featureCollection([
  turf.point([-63.601226, 44.642643]),
  turf.point([-63.591442, 44.651436]),
  turf.point([-63.580799, 44.648749]),
  turf.point([-63.573589, 44.641788]),
  turf.point([-63.587665, 44.64533]),
  turf.point([-63.595218, 44.64765]),
]);
var options = { units: "miles", maxEdge: 1 };

var hull = turf.concave(points, options);

convex 生成凸多边行范围

接受一个Feature或FeatureCollection，并返回一个凸包Polygon。在内部，这使用实现了monotone chain hull的convex-hull模块。

特点: 凸多边形是一个不会向内部弯曲的形状，所有的内角都小于或等于180度。它将所有输入点包含在内并包围起来，但不会产生凹入的部分。
适用场景: 当你需要生成一个简单的、多边形包围一组点，且不关心内部的细节（例如凹入特征）时，使用 convex。凸多边形在计算几何问题和简化形状时非常有用。

用法：

convex(points, options?)

参数:

points (FeatureCollection<Point>): 输入的点集合
options ({concavity?: number, properties?: Object}): concavity: 1 - thin shape. Infinity - convex hull. (default Infinity)

返回：

(Feature)

例子：

var points = turf.featureCollection([
  turf.point([10.195312, 43.755225]),
  turf.point([10.404052, 43.8424511]),
  turf.point([10.579833, 43.659924]),
  turf.point([10.360107, 43.516688]),
  turf.point([10.14038, 43.588348]),
  turf.point([10.195312, 43.755225]),
]);

var hull = turf.convex(points);

lineSegment 把多坐标点线的每相邻两个点截取为一条短线

把 (Multi)LineString or (Multi)Polygon的每相邻两个点截取为一条短线(只包含两个顶点)

用法：

lineSegment(geojson)

参数:

geojson (GeoJSON): GeoJSON Polygon or LineString

返回：

(FeatureCollection) 只包含两个顶点的线段集合

例子：

var polygon = turf.polygon([
  [
    [-50, 5],
    [-40, -10],
    [-50, -10],
    [-40, 5],
    [-50, 5],
  ],
]);
var segments = turf.lineSegment(polygon);

lineSlice 根据两个点截取线

根据输入的两个坐标截取线。这两个坐标不是必须精确的落在线上

用法：

lineSlice(startPoint, endPoint, line)

参数:

startPoint (Coord): 起点
endPoint (Coord): 终点
line (Feature<LineString>): 线

返回：

(Feature)

例子：

var line = turf.lineString([
  [-77.031669, 38.878605],
  [-77.029609, 38.881946],
  [-77.020339, 38.884084],
  [-77.025661, 38.885821],
  [-77.021884, 38.889563],
  [-77.019824, 38.892368],
]);
var start = turf.point([-77.029609, 38.881946]);
var stop = turf.point([-77.021884, 38.889563]);

var sliced = turf.lineSlice(start, stop, line);

lineSliceAlong 根据两个距离截取线

提供从线头开始的两个距离，分别计算出起始点和终止点，然后截取线

用法：

lineSliceAlong(line, startDist, stopDist, options?)

参数:

line (Feature<LineString>): 线
startDist (number): 起始距离
stopDist (number): 终止距离
options?.units? (string): 单位，默认'kilometers'

返回：

(Feature)

例子：

var line = turf.lineString([
  [7, 45],
  [9, 45],
  [14, 40],
  [14, 41],
]);
var start = 12.5;
var stop = 25;
var sliced = turf.lineSliceAlong(line, start, stop, { units: "miles" });

lineSplit 根据另一个要素要分割线

根据另一个GeoJSON要素来分割线

用法：

lineSplit(line, splitter)

参数:

line (Feature<LineString>): 线
splitter (Feature<any>): 用来分割线的要素

返回：

(FeatureCollection)

例子：

var line = turf.lineString([
  [120, -25],
  [145, -25],
]);
var splitter = turf.lineString([
  [130, -15],
  [130, -35],
]);

var split = turf.lineSplit(line, splitter);

横向的这根线被竖向的线分割成了两段

lineChunk 根据指定长度分割线

将LineString分割成指定长度的小段

用法：

lineChunk(geojson, segmentLength, options?)

参数:

geojson (FeatureCollection | Geometry | Feature<LineString | MultiLineString>): 需要分割的线
segmentLength (number): 分割长度
options?.units? (string): 单位，默认'kilometers'
options?.reverse? (boolean): 是否反向分割，默认false

返回：

(FeatureCollection)

例子：

var line = turf.lineString([
  [-95, 40],
  [-93, 45],
  [-85, 50],
]);

var chunk = turf.lineChunk(line, 15, { units: "miles" });

polygonTangents 点到多边形的切线

从一个点找到一个(Multi)Polygon的切线。

用法:

polygonTangents(point, polygon)

参数:

point (Feature<Point> | Coord): 点
polygon (Feature<Polygon | MultiPolygon>): 多边形

返回:

(FeatureCollection<Point>): 包含两个点的集合，因为切线有两条

例子:

var polygon = turf.polygon([
  [
    [11, 0],
    [22, 4],
    [31, 0],
    [31, 11],
    [21, 15],
    [11, 11],
    [11, 0],
  ],
]);
var point = turf.point([61, 5]);

var tangents = turf.polygonTangents(point, polygon);

mask 从一个区域(掩膜)中挖去一块区域

提供一个多边形，和一个可选的掩膜要素(不提供则默认为掩膜覆盖全球)，然后从掩膜中挖去多边形区域。剩余的区域作为多边形对象返回

用法：

mask(polygon, mask?)

参数:

polygon (FeatureCollection | Feature<Polygon | MultiPolygon>): 需要挖去的区域
mask? (Feature<Polygon>): 掩膜，不提供则默认为掩膜覆盖全球

返回：

(Feature)

例子：

var polygon = turf.polygon([
  [
    [112, -21],
    [116, -36],
    [146, -39],
    [153, -24],
    [133, -10],
    [112, -21],
  ],
]);
var mask = turf.polygon([
  [
    [90, -55],
    [170, -55],
    [170, 10],
    [90, 10],
    [90, -55],
  ],
]);

var masked = turf.mask(polygon, mask);

pointOnFeature 生成一个必定在要素上的范围内的点

接受一个要素或要素集合，并返回一个确保位于该要素表面上的点。（有点类似于中心点）

给定一个多边形，该点将位于多边形的区域内。
给定一个LineString，该点将沿着该线段。
给定一个点，输出的点将与输入相同。

用法:

pointOnFeature(feature)

参数:

feature (GeoJSON): 要素

返回:

(Feature<Point>): 点

例子:

var polygon = turf.polygon([
  [
    [116, -36],
    [131, -32],
    [146, -43],
    [155, -25],
    [133, -9],
    [111, -22],
    [116, -36],
  ],
]);

var pointOnPolygon = turf.pointOnFeature(polygon);

unkinkPolygon 自动拆分自交多边形

自动拆分自交的多边形，并返回拆分后的多边形集合

用法：

unkinkPolygon(polygon)

参数:

polygon (FeatureCollection | Feature<Polygon | MultiPolygon>): 多边形

返回：

(FeatureCollection)

例子：

var poly = turf.polygon([
  [
    [0, 0],
    [2, 0],
    [0, 2],
    [2, 2],
    [0, 0],
  ],
]);

var result = turf.unkinkPolygon(poly);

八. Random 随机

randomLineString 生成随机的线

randomLineString 生成随机的linestring

用法：

randomLineString(count?, options?)

参数:

count? (number): 生成多少个几何体默认 1
options?.bbox? (Array<number>): 生成线的范围（default [-180,-90,180,90]）
options?.num_vertices? (number): 每条线包含的顶点坐标数量默认10
options?.max_length? (number): 两顶点之间的最大距离默认0.0001
options?.max_rotation? (number): 两段线直接的最大弧度角默认 Math.PI/8

返回：

(FeatureCollection)

例子：

var lineStrings = turf.randomLineString(25, { bbox: [-180, -90, 180, 90] });
// => lineStrings

randomPoint 生成随机的点

随机生成point

用法：

randomPoint(count?, options?)

参数:

count? (number): 生成多少个几何体默认 1
options?.bbox? (Array<number>): 生成线的范围（default [-180,-90,180,90]）

返回：

(FeatureCollection)

例子：

var points = turf.randomPoint(25, { bbox: [-180, -90, 180, 90] });
// => points

randomPolygon 生成随机多边形

随机生成polygon

用法：

randomPolygon(count?, options?)

参数:

count? (number): 生成多少个几何体默认 1
options?.bbox? (Array<number>): 生成线的范围（default [-180,-90,180,90]）
options?.num_vertices? (number): 每个多边形包含的顶点坐标数量默认10
options?.max_radial_length? (number): is the maximum number of decimal degrees latitude or longitude that a vertex can reach out of the center of the Polygon. (default 10)

返回：

(FeatureCollection)

例子：

var polygons = turf.randomPolygon(25, { bbox: [-180, -90, 180, 90] });
// => polygons

randomPosition 生成一个随机位置

生成一个随机位置：[number, number]

用法：

randomPosition(bbox?)

参数:

bbox? ([number, number, number, number]): 生成线的范围（default [-180,-90,180,90]）

返回：

([number, number])

例子：

var position = turf.randomPosition([-180, -90, 180, 90]); //  [175.99717868600436, 23.778125886711308]
// => position

sample 随机抽样

在给定的集合中随机抽取指定数量的样本

用法：

sample(features, num)

参数:

features (FeatureCollection): 要素集合
num (number): 样本数量

返回：

(FeatureCollection)

例子：

var points = turf.randomPoint(100, { bbox: [-80, 30, -60, 60] });

var sample = turf.sample(points, 5);

十. Interpolation 插值

interpolate
isobands
isolines
planepoint
tin

十二. Grids 网格

hexGrid 生成六角网格

获取一个边界范围、单元格直径。然后返回一个元素集合，包含六角形或三角形

用法：

hexGrid(bbox, cellSide, options?)

参数:

bbox (BBox): 区域范围 [minX, minY, maxX, maxY]
cellSide (number): 六边形或三角形的边长，它也将于六边形的外接圆的半径重合
options?.units? (string): 半径单位
options?.properties? (Object): 生成的要素的属性值
options?.mask? (Feature<Polygon>): 如果传入一个多边形，这个网格点只会在多边形区域内生成
options?.triangles? (FeatureCollection<Polygon>): 是否返回三角形而不是六边形

返回：

(FeatureCollection)

例子：

var bbox = [-96, 31, -84, 40];
var cellSide = 50;
var options = { units: "miles" };

var hexgrid = turf.hexGrid(bbox, cellSide, options);

pointGrid 生成点网格

在一片区域内生成点网格

用法：

pointGrid(bbox, cellSide, options?)

参数:

bbox (BBox): 区域范围 [minX, minY, maxX, maxY]
cellSide (number): 两个点之间的距离
options?.units? (string): 距离单位
options?.properties? (Object): 生成的要素的属性值
options?.mask? (Feature<Polygon>): 如果传入一个多边形，这个网格点只会在多边形区域内生成

返回：

(FeatureCollection)

例子：

var extent = [-70.823364, -33.553984, -70.473175, -33.302986];
var cellSide = 3;
var options = { units: "miles" };

var grid = turf.pointGrid(extent, cellSide, options);

squareGrid 生成方形网格

在一片区域内生成方形网格

用法：

squareGrid(bbox, cellSide, options?)

参数:

bbox (BBox): 区域范围 [minX, minY, maxX, maxY]
cellSide (number): 单元格边长
options?.units? (string): 距离单位
options?.properties? (Object): 生成的要素的属性值
options?.mask? (Feature<Polygon>): 如果传入一个多边形，这个网格点只会在多边形区域内生成

返回：

(FeatureCollection)

例子：

var bbox = [-95, 30, -85, 40];
var cellSide = 50;
var options = { units: "miles" };

var squareGrid = turf.squareGrid(bbox, cellSide, options);

triangleGrid 生成三角网格

在一片区域内生成三角网格

用法：

triangleGrid(bbox, cellSide, options?)

参数:

bbox (BBox): 区域范围 [minX, minY, maxX, maxY]
cellSide (number): 单元格尺寸
options?.units? (string): 尺寸单位
options?.properties? (Object): 生成的要素的属性值
options?.mask? (Feature<Polygon>): 如果传入一个多边形，这个网格点只会在多边形区域内生成

返回：

(FeatureCollection)

例子：

var bbox = [-95, 30, -85, 40];
var cellSide = 50;
var options = { units: "miles" };

var triangleGrid = turf.triangleGrid(bbox, cellSide, options);

十四. Aggregation 聚合

clustersDbscan
clustersKmeans
collect
clusterEach
clusterReduce
getCluster

十五. Meta 元数据

coordAll 获取所有坐标

获取任何GeoJson对象的所有坐标

用法：

coordAll(geojson)

参数:

geojson (FeatureCollection | Feature | Geometry):

返回：

(Array<Array>)

例子：

var features = turf.featureCollection([
  turf.point([26, 37], { foo: "bar" }),
  turf.point([36, 53], { hello: "world" }),
]);

var coords = turf.coordAll(features);
//= [[26, 37], [36, 53]]

coordEach 坐标遍历

遍历GeoJson对象的所有坐标，类似Array.forEach()

用法：

coordEach(geojson, callback, excludeWrapCoord)

参数:

geojson (FeatureCollection | Feature | Geometry):
callback (Function): 遍历的回调方法，接受参数 (currentCoord, coordIndex, featureIndex, multiFeatureIndex)
geojson (FeatureCollection | Feature | Geometry): 对于环线，是否包含最后一个点的坐标，默认false

返回：

(void)

例子：

var features = turf.featureCollection([
  turf.point([26, 37], { foo: "bar" }),
  turf.point([36, 53], { hello: "world" }),
]);

turf.coordEach(
  features,
  function (
    currentCoord,
    coordIndex,
    featureIndex,
    multiFeatureIndex,
    geometryIndex,
  ) {
    //=currentCoord
    //=coordIndex
    //=featureIndex
    //=multiFeatureIndex
    //=geometryIndex
  },
);

coordReduce 坐标遍历缩减-Array.reduce

featureEach 要素遍历-Array.forEach

featureReduce 要素遍历缩减-Array.reduce

flattenEach 扁平遍历--Array.forEach

flattenReduce 扁平遍历--Array.reduce

geomEach 几何图形遍历--Array.forEach

geomReduce 几何图形遍历--Array.reduce

propEach 属性遍历--Array.forEach

propReduce 属性遍历--Array.reduce

segmentEach 多坐标元素拆分遍历--Array.forEach

segmentReduce 多坐标元素拆分遍历--Array.reduce

getCoord 解包坐标(Point Feature, Geometry or a single coordinate)

从Point Feature, Geometry or a single coordinate中解包坐标

用法：

getCoord(coord)

参数:

coord (Array<number> | Geometry<Point> | Feature<Point>):

返回：

([number, number])

例子：

var pt = turf.point([10, 10]);

var coord = turf.getCoord(pt);
//= [10, 10]

getCoords 解包坐标(Feature, Geometry Object or an Array)

从Feature, Geometry Object or an Array中解包坐标

用法：

getCoords(coords)

参数:

coords (Array<any> | Geometry | Feature): 几何体

返回：

(Array)

例子：

var poly = turf.polygon([
  [
    [119.32, -8.7],
    [119.55, -8.69],
    [119.51, -8.54],
    [119.32, -8.7],
  ],
]);

var coords = turf.getCoords(poly);
//= [[[119.32, -8.7], [119.55, -8.69], [119.51, -8.54], [119.32, -8.7]]]

十六. 类型守卫

getType 获取GeoJson对象类型

获取GeoJson对象类型，优先拿Geometry的类型

用法：

getType(geojson, name?)

参数:

geojson (Geometry): 几何体
name? (string): name of the variable to display in error message (unused) (default "geojson")

返回：

(string)

例子：

var point = {
  type: "Feature",
  properties: {},
  geometry: {
    type: "Point",
    coordinates: [110, 40],
  },
};
var geom = turf.getType(point);
//="Point"

featureOf 要素的类型是否匹配指定类型

强制执行对Turf的Feature输入类型的期望。内部使用geojsonType来判断几何类型

用于验证 GeoJSON 对象是否是指定类型的几何集合。它通常在开发中用来确保函数接收到的数据是预期类型的集合，避免数据类型错误引发的潜在问题。

主要用途：

数据验证: 在处理 GeoJSON 数据前，确保其为指定类型的要素（如 Point, LineString, Polygon 等）。
错误捕获: 在运行复杂的地理分析之前，通过类型检查捕获数据错误。

用法：

featureOf(feature, type, name)

参数:

feature (Feature): 待检查的 GeoJSON Feature 对象。
type (string): 期望的几何类型，如 Point, LineString, Polygon 等。
name (string): 当前函数或操作的名称，用于在错误信息中标识，便于调试。

返回：

如果 feature 特征是指定的类型，turf.featureOf 将返回 true。如果检测到类型不匹配，则会抛出错误，提供详细的错误信息。

例子：

try {
  turf.featureOf(turf.lineString([[30, 30], [40, 40]]), 'Point', 'myFunction');
  console.log("All features are Points.");
} catch (e) {
  console.error(e.message);
}

// turfdemo1.html:24 Invalid input to myFunction: must be a Point, given LineString

collectionOf 集合中是否全部包含指定类型

强制执行对Turf的FeatureCollection输入类型的期望。内部使用geojsonType来判断几何类型

用于验证 GeoJSON 对象是否包含指定类型的几何集合。它通常在开发中用来确保函数接收到的数据是预期类型的集合，避免数据类型错误引发的潜在问题。

主要用途：

数据验证: 在处理 GeoJSON 数据前，确保其为指定类型的集合（如 Point, LineString, Polygon 等）。
错误捕获: 在运行复杂的地理分析之前，通过类型检查捕获数据错误。

用法：

collectionOf(featureCollection, type, name)

参数:

featureCollection (FeatureCollection): 待检查的 GeoJSON FeatureCollection 对象。此对象应该包含一组几何特征（如点、线、面等）
type (string): 期望的几何类型，如 Point, LineString, Polygon 等。
name (string): 当前函数或操作的名称，用于在错误信息中标识，便于调试。

返回：

如果 featureCollection 中的所有特征都是指定的类型，turf.collectionOf 将返回 true。如果检测到类型不匹配，则会抛出错误，提供详细的错误信息。

例子：

const turf = require('@turf/turf');

// 创建一个 FeatureCollection，其中包含点和线
const featureCollection = turf.featureCollection([
  turf.point([10, 10]),
  turf.point([20, 20]),
  turf.lineString([[30, 30], [40, 40]])
]);

// 验证 featureCollection 中的所有特征是否都是 Point 类型
try {
  turf.collectionOf(featureCollection, 'Point', 'myFunction');
  console.log("All features are Points.");
} catch (e) {
  console.error(e.message);
}

// turfdemo1.html:24 Invalid input to myFunction: must be a Point, given LineString

geojsonType 地理数据的类型是否匹配指定类型

强制执行对Turf的Feature输入类型的期望。内部使用geojsonType来判断几何类型

用于验证 GeoJSON 对象是否是指定类型的几何集合。它通常在开发中用来确保函数接收到的数据是预期类型的集合，避免数据类型错误引发的潜在问题。

用发和作用同featureOf, 区别：geojsonType 更通用，可以验证任意 GeoJSON 数据的类型，而 featureOf 只适用于 Feature 对象，并且只能验证 geometry 的类型。在编写处理 GeoJSON 数据的代码时，选择哪个函数取决于你需要验证的数据类型的范围。

containsNumber 是否包含数值

booleanClockwise 环是否是顺时针

判断一个环线坐标是否是顺时针

用法：

booleanClockwise(line)

参数:

line (Feature<LineString> | LineString | Array<Array<number>>): 几何体

返回：

(boolean)

例子：

var clockwiseRing = turf.lineString([
  [0, 0],
  [1, 1],
  [1, 0],
  [0, 0],
]);
var counterClockwiseRing = turf.lineString([
  [0, 0],
  [1, 0],
  [1, 1],
  [0, 0],
]);

turf.booleanClockwise(clockwiseRing);
//=true
turf.booleanClockwise(counterClockwiseRing);
//=false

booleanConcave 多边形是否凹

判断多边形是否凹

用法：

booleanConcave(polygon)

参数:

polygon (Feature<Polygon>): 几何体

返回：

(boolean)

例子：

var convexPolygon = turf.polygon([
  [
    [0, 0],
    [0, 1],
    [1, 1],
    [1, 0],
    [0, 0],
  ],
]);

turf.booleanConcave(convexPolygon);
//=false

booleanContains 第二个要素是否完全包含在第一个要素中

两个几何图形的内部必须相交
次要几何图形的内部和边界不得与主要几何图形的外部相交
结果与booleanWithin相反

用法：

booleanContains(feature1, feature2)

参数:

feature1 (Geometry | Feature<any>): 要素1
feature2 (Geometry | Feature<any>): 要素2

返回：

(boolean)

例子：

var line = turf.lineString([
  [1, 1],
  [1, 2],
  [1, 3],
  [1, 4],
]);
var point = turf.point([1, 2]);

turf.booleanContains(line, point);
//=true

booleanWithin 第一个要素是否完全包含在第二个要素中

两个几何图形的内部必须相交
主要几何图形的内部和边界不得与次要几何图形的外部相交
结果与booleanContains相反

用法：

booleanWithin(feature1, feature2)

参数:

feature1 (Geometry | Feature<any>): 要素1
feature2 (Geometry | Feature<any>): 要素2

返回：

(boolean)

例子：

var line = turf.lineString([
  [1, 1],
  [1, 2],
  [1, 3],
  [1, 4],
]);
var point = turf.point([1, 2]);

turf.booleanWithin(point, line);
//=true

booleanTouches 是否刚好接触

两个要素是否刚好接触（两个几何图形的公共点均不与两个几何图形内部相交）

用法：

booleanTouches(feature1, feature2)

参数:

feature1 (Geometry | Feature<any>): 要素1
feature2 (Geometry | Feature<any>): 要素2

返回：

(boolean)

例子：

var line = turf.lineString([
  [1, 1],
  [1, 2],
  [1, 3],
  [1, 4],
]);
var point = turf.point([1, 1]);

turf.booleanTouches(point, line);
//=true

booleanCrosses 是否交叉

如果交集产生的几何体的尺寸比两个源几何体的最大尺寸下，并且交集位于两个源集合的内部，则返回true 只支持以下要素的比较：multipoint/polygon, multipoint/linestring, linestring/linestring, linestring/polygon, linestring/multipolygon 注意完全包含会返回false 注意仅仅只是边缘接触返回false

用法：

booleanCrosses(feature1, feature2)

参数:

feature1 (Geometry | Feature<any>): 要素1
feature2 (Geometry | Feature<any>): 要素2

返回：

(boolean)

例子：

var line1 = turf.lineString([
  [-2, 2],
  [4, 2],
]);
var line2 = turf.lineString([
  [1, 1],
  [1, 2],
  [1, 3],
  [1, 4],
]);

var cross = turf.booleanCrosses(line1, line2);
//=true

booleanIntersects 是否相交

如果两个要素相交返回true

和booleanCrosses的区别：

booleanIntersects判断两个几何对象是否存在任意形式的相交,如果两个几何对象有任意一部分重叠、接触或交叠，即便只是一个点或边相接触，那么它们被认为是相交的
booleanCrosses判断一个几何对象是否穿过另一个几何对象，即部分相交.如果两个几何对象相交的部分并不只是边界上的接触，而是几何对象内部的一部分与另一个几何对象的内部部分相交（即几何对象的维度会降低，例如线穿过多边形，或点穿过线），它们被认为是交叉的。注意: 如果一个对象完全包含在另一个对象内部，booleanCrosses将返回false，因为这种情况不符合“交叉”的定义

用法：

booleanIntersects(feature1, feature2)

参数:

feature1 (Geometry | Feature<any>): 要素1
feature2 (Geometry | Feature<any>): 要素2

返回：

(boolean)

例子：

var point = turf.point([2, 2]);
var line = turf.lineString([
  [1, 1],
  [1, 2],
  [1, 3],
  [1, 4],
]);

turf.booleanIntersects(line, point);
//=true= turf.booleanCrosses(line1, line2);
//=true

booleanDisjoint 是否不拼接

如果交集是空集，就返回true

用法：

booleanDisjoint(feature1, feature2)

参数:

feature1 (Geometry | Feature<any>): 要素1
feature2 (Geometry | Feature<any>): 要素2

返回：

(boolean)

例子：

var point = turf.point([2, 2]);
var line = turf.lineString([
  [1, 1],
  [1, 2],
  [1, 3],
  [1, 4],
]);

turf.booleanDisjoint(line, point);
//=true

booleanEqual 同一类型的图形是否拥有相同的坐标

确定同一类型的两个几何图形是否具有相同的x，y坐标值

用法：

booleanEqual(feature1, feature2, options?)

参数:

feature1 (Geometry | Feature<any>): 要素1
feature2 (Geometry | Feature<any>): 要素2
options?.precision? (number): 比较坐标时使用的小数精度（default 6）

返回：

(boolean)

例子：

var pt1 = turf.point([0, 0]);
var pt2 = turf.point([0, 0]);
var pt3 = turf.point([1, 1]);

turf.booleanEqual(pt1, pt2);
//= true
turf.booleanEqual(pt2, pt3);
//= false

booleanOverlap 两个要素是否部分重叠

booleanParallel 两条线是否平行

如果两条线的每一个对应线段平行，则返回true

用法：

booleanParallel(feature1, feature2)

参数:

feature1 (Geometry | Feature<LineString>): 要素1
feature2 (Geometry | Feature<LineString>): 要素2

返回：

(boolean)

例子：

var line1 = turf.lineString([
  [0, 0],
  [0, 1],
]);
var line2 = turf.lineString([
  [1, 0],
  [1, 1],
]);

turf.booleanParallel(line1, line2);
//=true

booleanPointInPolygon 点是否在多边形中

判断点是否在(多)多边形内

用法：

booleanPointInPolygon(point, polygon, options?)

参数:

point (Coord): 点
polygon (Feature<Polygon | MultiPolygon>): 多边形
options?.ignoreBoundary? (boolean): 为true时，点在多边形边界上时不算在内部（default: false）

返回：

(boolean)

例子：

var pt = turf.point([-77, 44]);
var poly = turf.polygon([
  [
    [-81, 41],
    [-81, 47],
    [-72, 47],
    [-72, 41],
    [-81, 41],
  ],
]);

turf.booleanPointInPolygon(pt, poly);
//= true

booleanPointOnLine 点是否在线上

判断点是否线上

用法：

booleanPointOnLine(point, line, options?)

参数:

point (Coord): 点
line (Feature<LineString>): 线
options?.ignoreEndVertices? (boolean): 是否忽略开始和结束的顶点（default: false）
options?.epsilon? (number): 计算偏差时允许的误差值（default: 0）

返回：

(boolean)

例子：

var pt = turf.point([0, 0]);
var line = turf.lineString([
  [-1, -1],
  [1, 1],
  [1.5, 2.2],
]);
var isPointOnLine = turf.booleanPointOnLine(pt, line);
//=true

booleanValid 是否是有效的几何图形

根据 OGC Simple Feature Specification 判断输入是否是有效的几何图形

用法：

booleanValid(feature)

参数:

feature (Geometry | Feature<any>): 输入的要素

返回：

(boolean)

例子：

var line = turf.lineString([
  [1, 1],
  [1, 2],
  [1, 3],
  [1, 4],
]);

turf.booleanValid(line); // => true
turf.booleanValid({ foo: "bar" }); // => false

十九. 其他

clone 深复制GeoJSON对象

返回传递的GeoJSON对象的克隆副本，包括可能的'Foreign Members'。比常见的JSON.parse + JSON.stringify组合方法快大约3-5倍。

用法：

clone(geojson)

参数:

geojson (GeoJSON): 地理对象

返回：

(GeoJSON)

例子：

var line = turf.lineString(
  [
    [-74, 40],
    [-78, 42],
    [-82, 35],
  ],
  { color: "red" },
);

var lineCloned = turf.clone(line);

tag 标记空间连接

接受一组点和一组多边形和/或多多边形，并执行空间连接。

用于为一组点（Point）添加属性标签，这些属性来源于一组输入多边形（Polygon）或多点（MultiPoint）。turf.tag 是进行地理空间分析时的一种空间连接操作，它可以为点数据附加来自邻近几何对象的属性信息。

主要用途：

空间连接: 为点数据集添加邻近多边形或多点的数据属性。
区域归类: 将点归类到其所在的多边形区域中，并为其附加该区域的属性。
数据增强: 通过将多边形或多点数据的属性添加到点数据中，增强点数据的表达能力。

典型应用场景:

地理分析: 为每个采样点（如气象站、传感器等）添加其所属的区域属性（如行政区、气候区等）。
数据分类: 根据点所在的多边形区域进行分类或归属判定。
空间统计: 结合多边形区域属性为点数据进行聚类或统计分析。

注意：

如果一个点位于多个多边形内部，turf.tag 将仅添加第一个匹配多边形的属性值
如果一个点不在任何多边形内部，则不会为其添加 outField 字段，或者该字段值为 undefined。

用法：

tag(points, polygons, field, outField)

参数:

points (FeatureCollection<Point>): 点集合
polygons (FeatureCollection<Polygon | MultiPolygon>): 面集合
field (string): 面中要取值的字段
outField (string): 点中要复制的字段

返回：

(FeatureCollection<Point)

例子：

var pt1 = turf.point([-77, 44]);
var pt2 = turf.point([-77, 38]);
var poly1 = turf.polygon(
  [
    [
      [-81, 41],
      [-81, 47],
      [-72, 47],
      [-72, 41],
      [-81, 41],
    ],
  ],
  { pop: 3000 },
);
var poly2 = turf.polygon(
  [
    [
      [-81, 35],
      [-81, 41],
      [-72, 41],
      [-72, 35],
      [-81, 35],
    ],
  ],
  { pop: 1000 },
);

var points = turf.featureCollection([pt1, pt2]);
var polygons = turf.featureCollection([poly1, poly2]);

var tagged = turf.tag(points, polygons, "pop", "population");

directionalMean 线的平均方向

distanceWeight 距离权重

findPoint 根据索引找点

findSegment 根据索引找某一段线

moranIndex

pNormDistance

fun

用法：

bboxClip(geojson)

参数:

geojson (Geometry): 几何体

返回：

(boolean)

例子：