MapGIS Client for JavaScript API

# static buffer(geometryopt, distanceopt, unitopt, unionResultsopt)

参数:

示例

区缓冲分析

// ES5引入方式
const { Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Polygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造多边形
const polygon = new Polygon({
  coordinates: [
    [
      [108.36341, 29.032578],
      [116.13094, 29.032578],
      [116.13094, 33.273224],
      [108.36341, 33.273224],
      [108.36341, 29.032578],
    ]
  ]
})
// 执行缓冲区分析
const bufferedPolygon = GeometryEngine.buffer(polygon, 100000)

多区缓冲分析

// ES5引入方式
const { MultiPolygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { MultiPolygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造多边形
const polygon = new MultiPolygon({
  coordinates: [
    [
      [
        [108.36341, 29.032578],
        [112.13094, 29.032578],
        [112.13094, 33.273224],
        [108.36341, 33.273224],
        [108.36341, 29.032578],
      ]
    ],
    [
      [
        [113.36341, 29.032578],
        [116.13094, 29.032578],
        [116.13094, 33.273224],
        [113.36341, 33.273224],
        [113.36341, 29.032578],
      ]
    ]
  ]
})
// 执行缓冲区分析
const bufferedPolygon = GeometryEngine.buffer(polygon, 30000)

几何对象数组的缓冲区分析

// ES5引入方式
const { Polygon, MultiPolygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Polygon, MultiPolygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造多边形
const polygon1 = new MultiPolygon({
  coordinates: [
    [
      [
        [110.36341, 29.032578],
        [112.13094, 29.032578],
        [112.13094, 33.273224],
        [110.36341, 33.273224],
        [110.36341, 29.032578],
      ]
    ],
    [
      [
        [113.36341, 29.032578],
        [116.13094, 29.032578],
        [116.13094, 33.273224],
        [113.36341, 33.273224],
        [113.36341, 29.032578],
      ]
    ]
  ]
})
// 构造多边形2
const polygon2 = new Polygon({
  coordinates: [
    [
      [108.36341, 29.032578],
      [109.13094, 29.032578],
      [109.13094, 33.273224],
      [108.36341, 33.273224],
      [108.36341, 29.032578],
    ]
  ]
})
// 执行缓冲区分析，distance可谓数字或数组
const bufferedPolygon = GeometryEngine.buffer([polygon1, polygon2], [30000, 30000])

几何数组缓冲区分析 - 分析结果几何求并

// ES5引入方式
const { Polygon, MultiPolygon, LengthUnit, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Polygon, MultiPolygon, LengthUnit, GeometryEngine } from "@mapgis/webclient-common"
// 构造多边形
const polygon1 = new MultiPolygon({
  coordinates: [
    [
      [
        [110.36341, 29.032578],
        [112.13094, 29.032578],
        [112.13094, 33.273224],
        [110.36341, 33.273224],
        [110.36341, 29.032578],
      ]
    ],
    [
      [
        [113.36341, 29.032578],
        [116.13094, 29.032578],
        [116.13094, 33.273224],
        [113.36341, 33.273224],
        [113.36341, 29.032578],
      ]
    ]
  ]
})
// 构造多边形2
const polygon2 = new Polygon({
  coordinates: [
    [
      [108.36341, 29.032578],
      [109.13094, 29.032578],
      [109.13094, 33.273224],
      [108.36341, 33.273224],
      [108.36341, 29.032578],
    ]
  ]
})
// 执行缓冲区分析，设置unionResults参数为true
const bufferedPolygon = GeometryEngine.buffer([polygon1, polygon2], [30000], LengthUnit.meter, true)

区缓冲分析 - 自定义坐标系

// ES5引入方式
const { Polygon, SpatialReference, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Polygon, SpatialReference, GeometryEngine } from "@mapgis/webclient-common"
// 构造多边形
const polygon = new Polygon({
  coordinates: [
    [
      [-45257.10778559791, 3212885.1836444484],
      [705989.8953363781, 3212885.1836444484],
      [705989.8953363781, 3691623.86404564],
      [-45257.10778559791, 3691623.86404564],
      [-45257.10778559791, 3212885.1836444484],
    ]
  ],
  // 注意要指定坐标系
  spatialReference: new SpatialReference({
    wkid: 4547
  })
})
// 执行缓冲区分析
const bufferedPolygon = GeometryEngine.buffer(polygon, 100000)

点缓冲分析

// ES5引入方式
const { Point, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Point, GeometryEngine } from "@mapgis/webclient-common"
// 构造点几何
const point = new Point({
  coordinates: [108.36341, 29.032578]
})
// 执行缓冲区分析
const bufferedPolygon = GeometryEngine.buffer(point, 100000)

线缓冲分析

// ES5引入方式
const { LineString, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, GeometryEngine } from "@mapgis/webclient-common"
// 构造线
const lineString = new LineString({
  coordinates: [
    [108.36341, 29.032578],
    [109.36341, 29.032578]
  ]
})
// 执行缓冲区分析
const bufferedPolygon = GeometryEngine.buffer(lineString, 10000)

矩形缓冲分析

// ES5引入方式
const { LineString, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, GeometryEngine } from "@mapgis/webclient-common"
// 构造矩形
const extent = new Extent({
  xmin: 112,
  xmax: 114,
  ymin: 30,
  ymax: 32
})
// 执行缓冲区分析
const bufferedPolygon = GeometryEngine.buffer(extent, 10000)

圆形缓冲分析

// ES5引入方式
const { Circle, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Circle, GeometryEngine } from "@mapgis/webclient-common"
// 构造圆形
const circle = new Circle({
  center: [112, 30],
  radius: 3
})
// 执行缓冲区分析
const bufferedPolygon = GeometryEngine.buffer(circle, 10000)

# static contains(containerGeometryopt, insideGeometryopt)

参数:

示例

区包含点

// ES5引入方式
const { Polygon, Point, GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine, Polygon, Point } from "@mapgis/webclient-common"
// 初始点几何，可以是任意几何
const point = new Point({
  coordinates: [1, 1]
})
// 初始化区几何，可以是任意几何
const polygon = new Polygon({
  coordinates: [
    [
      [1, 0],
      [10, 0],
      [10, 20],
      [1, 20],
      [1, 0]
    ]
  ]
})
// 判断区几何是否包含点几何对象
const isContains = GeometryEngine.contains(polygon, point)
console.log("区是否包含点:", isContains)

多点包含点

// ES5引入方式
const { MultiPoint, Point, GeometryEngine } = zondy.geometry
// ES6引入方式
import { MultiPoint, Point, GeometryEngine } from "@mapgis/webclient-common"
// 初始点几何
const point = new Point({
  coordinates: [1, 1]
})
// 初始化多点几何
const multiPoint = new MultiPoint({
  coordinates: [
    [1, 1],
    [1, 2]
  ]
})
// 判断多点几何是否包含点几何对象
const isContains = GeometryEngine.contains(multiPoint, point)
console.log("多点是否包含点:", isContains)

区包含线

// ES5引入方式
const { Polygon, LineString, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Polygon, LineString, GeometryEngine } from "@mapgis/webclient-common"
// 初始化区几何
const polygon = new Polygon({
  coordinates: [
    [
      [1, 0],
      [10, 0],
      [10, 20],
      [1, 20],
      [1, 0]
    ]
  ]
})
// 初始化线几何
const lineString = new LineString({
  coordinates: [
    [1, 0],
    [1, 6]
  ]
})
// 判断多点几何是否包含点几何对象
const isContains = GeometryEngine.contains(polygon, lineString)
console.log("区是否包含线:", isContains)

圆包含矩形

// ES5引入方式
const { Circle, LineString, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Circle, LineString, GeometryEngine } from "@mapgis/webclient-common"
// 初始化圆几何
const circle = new Circle({
  center: [5, 5],
  radius: 2
})
// 初始化矩几何
const extent = new Extent({
  xmin: 2,
  ymin: 2,
  xmax: 4,
  ymax: 4
})
// 判断多点几何是否包含点几何对象
const isContains = GeometryEngine.contains(circle, extent)
console.log("圆是否包含矩形:", isContains)

几何包含 - 自定义坐标系

// ES5引入方式
const { Polygon, LineString, SpatialReference, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Polygon, LineString, SpatialReference, GeometryEngine } from "@mapgis/webclient-common"
// 初始化线几何对象
const line = new LineString({
  coordinates: [
    [60000, 3426025],
    [598545, 3426025]
  ],
  // 要设置坐标系
  spatialReference: new SpatialReference({
    wkid: 4547
  })
})
// 初始化区几何对象
const polygon = new Polygon({
  coordinates: [
    [
      [0, 3226025],
      [698545, 3226025],
      [698545, 3685076],
      [0, 3685076],
      [0, 3226025]
    ],
    [
      [100000, 3326025],
      [598545, 3326025],
      [598545, 3485076],
      [100000, 3485076],
      [100000, 3326025]
    ]
  ],
  // 要设置坐标系
  spatialReference: new SpatialReference({
    wkid: 4547
  })
})
// 判断多点几何是否包含点几何对象
const isContains = GeometryEngine.contains(circle, extent)
console.log("圆是否包含矩形:", isContains)

# static crosses(geometry1, geometry2)

参数:

示例

线穿过线

// ES5引入方式
const { LineString, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, GeometryEngine } from "@mapgis/webclient-common"
// 构造要穿过的线对象
const line1 = new LineString({
  coordinates: [
    [108.36341, 29.032578],
    [116.13094, 29.032578]
  ]
})
// 构造被穿过的线对象
const line2 = new LineString({
  coordinates: [
    [110, 28],
    [110, 30],
    [111, 30],
    [111, 28]
  ]
})
// 开始判断穿过
const cross = GeometryEngine.crosses(line1, line2)
console.log("线是否穿过线:", cross)

线穿过多线

// ES5引入方式
const { LineString, MultiLineString, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, MultiLineString, GeometryEngine } from "@mapgis/webclient-common"
// 构造要穿过的线对象
const line1 = new LineString({
  coordinates: [
    [108.36341, 29.032578],
    [116.13094, 29.032578]
  ]
})
// 构造被穿过的多线对象
 const multiLineString = new MultiLineString({
  coordinates: [
    [
      [108.36341, 29.032578],
      [116.13094, 29.032578]
    ],
    [
      [108.36341, 29.332578],
      [116.13094, 29.332578]
    ]
  ]
})
// 开始判断穿过
const cross = GeometryEngine.crosses(line1, multiLineString)
console.log("线是否穿过多线:", cross)

线穿过区

// ES5引入方式
const { LineString, Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, Polygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造要穿过的线对象
const line = new LineString({
  coordinates: [
    [110, 28],
    [110, 34],
    [111, 34],
    [112, 28]
  ]
})
// 构造被穿过的区对象
const polygon = new Polygon({
  coordinates: [
    [
      [108.36341, 29.032578],
      [116.13094, 29.032578],
      [116.13094, 33.273224],
      [108.36341, 33.273224],
      [108.36341, 29.032578],
    ],
    [
      [109, 29.5],
      [112, 29.5],
      [112, 32],
      [109, 32],
      [109, 29.5],
    ]
  ]
})
// 开始判断穿过
const cross = GeometryEngine.crosses(line,polygon)
console.log("线是否穿过区:", cross)

多线穿过区

// ES5引入方式
const { MultiLineString, Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { MultiLineString, Polygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造要穿过的多线对象
 const multiLineString = new MultiLineString({
  coordinates: [
    [
      [108.36341, 29.032578],
      [116.13094, 29.032578]
    ],
    [
      [108.36341, 29.332578],
      [116.13094, 29.332578]
    ]
  ]
})
// 构造被穿过的区对象
const polygon = new Polygon({
  coordinates: [
    [
      [108.36341, 29.032578],
      [116.13094, 29.032578],
      [116.13094, 33.273224],
      [108.36341, 33.273224],
      [108.36341, 29.032578],
    ],
    [
      [109, 29.5],
      [112, 29.5],
      [112, 32],
      [109, 32],
      [109, 29.5],
    ]
  ]
})
// 开始判断穿过
const cross = GeometryEngine.crosses( multiLineString,polygon)
console.log("多线是否穿过区:", cross)

多线穿过多区

// ES5引入方式
const { MultiLineString, MultiPolygon, SpatialReference, GeometryEngine } = zondy.geometry
// ES6引入方式
import { MultiLineString, MultiPolygon, SpatialReference, GeometryEngine } from "@mapgis/webclient-common"
// 构造要穿过的多线对象
 const multiLineString = new MultiLineString({
  coordinates: [
    [
      [-49522.6942635386, 3226025.20474049],
      [707596.826929215, 3214754.20105]
    ],
    [
      [-47918.3624481045, 3259361.82328017],
      [707596.826929215, 3259361.82328017]
    ]
  ],
  // 必须指定坐标系
  spatialReference: new SpatialReference({
    wkid: 4547
  })
})
// 构造被穿过的多区
const multiPolygon = new MultiPolygon({
  coordinates: [
    [
      [
        [-47918.3624481045, 3214754.20105],
        [707596.826929215, 3214754.20105],
        [707596.826929215, 3685076.66188228],
        [-47918.3624481045, 3685076.66188228],
        [-47918.3624481045, 3214754.20105]
      ],
      [
        [14849.3479447439, 3275130.08942507],
        [310996.760637403, 3275130.08942507],
        [310996.760637403, 3543600.9315051],
        [14849.3479447439, 3543600.9315051],
        [14849.3479447439, 3275130.08942507],
      ]
    ],
    [
      [
        [813421.283605543, 3214754.20105],
        [1071620.19329204, 3214754.20105],
        [1071620.19329204, 3685076.66188228],
        [813421.283605543, 3685076.66188228],
        [813421.283605543, 3214754.20105]
      ]
    ]
  ],
  // 必须指定坐标系
  spatialReference: new SpatialReference({
    wkid: 4547
  })
})
// 开始判断穿过
const cross = GeometryEngine.crosses(multiLineString, multiPolygon)
console.log("多线是否穿过多区:", cross)

# static cut(geometry, cutter)

参数:

示例

线切割线

// ES5引入方式
const { LineString, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, GeometryEngine } from "@mapgis/webclient-common"
// 构造被切割的线对象
const line = new LineString({
  coordinates: [
    [108.36341, 29.032578],
    [116.13094, 29.032578]
  ]
})
// 构造切割线对象
const cutter = new LineString({
  coordinates: [
    [110, 28],
    [110, 30],
    [111, 30],
    [111, 28]
  ]
})
// 开始切割线
const cut = GeometryEngine.cut(line, cutter)
console.log("切割后的几何数组:", cut)

线切割多线

// ES5引入方式
const { LineString, MultiLineString, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, MultiLineString, GeometryEngine } from "@mapgis/webclient-common"
// 构造被切割的多线对象
const line = new MultiLineString({
  coordinates: [
    [
      [108.36341, 29.032578],
      [116.13094, 29.032578]
    ],
    [
      [108.36341, 29.332578],
      [116.13094, 29.332578]
    ]
  ]
})
// 构造切割线对象
const cutter = new LineString({
  coordinates: [
    [110, 28],
    [110, 30],
    [111, 30],
    [112, 28]
  ]
})
// 开始切割线
const cut = GeometryEngine.cut(line, cutter)
console.log("切割后的几何数组:", cut)

线切割区

// ES5引入方式
const { LineString, Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, Polygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造被切割的区对象
const polygon = new Polygon({
  coordinates: [
    [
      [108.36341, 29.032578],
      [116.13094, 29.032578],
      [116.13094, 33.273224],
      [108.36341, 33.273224],
      [108.36341, 29.032578],
    ],
    [
      [109, 29.5],
      [112, 29.5],
      [112, 32],
      [109, 32],
      [109, 29.5],
    ]
  ]
})
// 构造切割线对象
const cutter = new LineString({
  coordinates: [
    [110, 28],
    [110, 34],
    [111, 34],
    [112, 28]
  ]
})
// 开始切割区
const cut = GeometryEngine.cut(polygon, cutter)
console.log("切割后的几何数组:", cut)

线切割多区

// ES5引入方式
const { LineString, MultiPolygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, MultiPolygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造被切割的多区
const polygon = new MultiPolygon({
  coordinates: [
    [
      [
        [108.36341, 29.032578],
        [116.13094, 29.032578],
        [116.13094, 33.273224],
        [108.36341, 33.273224],
        [108.36341, 29.032578]
      ],
      [
        [109, 29.5],
        [112, 29.5],
        [112, 32],
        [109, 32],
        [109, 29.5],
      ]
    ],
    [
      [
        [117.36341, 29.032578],
        [120.13094, 29.032578],
        [120.13094, 33.273224],
        [117.36341, 33.273224],
        [117.36341, 29.032578]
      ]
    ]
  ]
})
// 构造切割线对象
const cutter = new LineString({
  coordinates: [
    [110, 28],
    [110, 34],
    [111, 34],
    [112, 28],
    [118, 28],
    [119, 34]
  ]
})
// 开始切割多区
const cut = GeometryEngine.cut(polygon, cutter)
console.log("切割后的几何数组:", cut)

几何切割 - 自定义坐标系

// ES5引入方式
const { LineString, Polygon, SpatialReference, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, Polygon, SpatialReference, GeometryEngine } from "@mapgis/webclient-common"
// 构造被切割的区对象
const polygon = new Polygon({
  coordinates: [
    [
      [0, 3226025],
      [698545, 3226025],
      [698545, 3685076],
      [0, 3685076],
      [0, 3226025]
    ],
    [
      [100000, 3326025],
      [598545, 3326025],
      [598545, 3485076],
      [100000, 3485076],
      [100000, 3326025]
    ]
  ],
  // 必须指定坐标系
  spatialReference: new SpatialReference({
    wkid: 4547
  })
})
// 构造切割线对象
const cutter = new LineString({
  coordinates: [
    [106372, 3104899],
    [130347, 3770883],
    [222797, 3767721],
    [303253, 3100054]
  ],
  // 必须指定坐标系
  spatialReference: new SpatialReference({
    wkid: 4547
  })
})
// 开始切割区
const cut = GeometryEngine.cut(polygon, cutter)
console.log("切割后的几何数组:", cut)

# static difference(inputGeometry, subtractGeometry)

参数:

示例

区和区求差

// ES5引入方式
const { Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Polygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造第一个区
const polygon1 = new Polygon({
  coordinates: [
    [
      [108.36341, 29.032578],
      [116.13094, 29.032578],
      [116.13094, 33.273224],
      [108.36341, 33.273224],
      [108.36341, 29.032578]
    ]
  ]
})
// 构造第二个区
onst polygon2 = new Polygon({
  coordinates: [
    [
      [109.36341, 30.032578],
      [115.13094, 30.032578],
      [115.13094, 32.273224],
      [109.36341, 32.273224],
      [109.36341, 30.032578]
    ],
    [
      [110.36341, 31.032578],
      [114.13094, 31.032578],
      [114.13094, 31.5],
      [110.36341, 31.5],
      [110.36341, 31.032578]
    ]
  ]
})
// 开始求差
const geometry = GeometryEngine.difference(polygon1, polygon2)
console.log("区和区求差：", geometry)

区和多区求差

// ES5引入方式
const { Polygon, MultiPolygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Polygon, MultiPolygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造第一个区
const polygon1 = new Polygon({
  coordinates: [
    [
      [108.36341, 29.032578],
      [116.13094, 29.032578],
      [116.13094, 33.273224],
      [108.36341, 33.273224],
      [108.36341, 29.032578]
    ]
  ]
})
// 构造第二个区
const polygon2 = new MultiPolygon({
  coordinates: [
    [
      [
        [109.36341, 30.032578],
        [110.13094, 30.032578],
        [110.13094, 32.273224],
        [109.36341, 32.273224],
        [109.36341, 30.032578]
      ]
    ],
    [
      [
        [111.36341, 30.032578],
        [112.13094, 30.032578],
        [112.13094, 32.273224],
        [111.36341, 32.273224],
        [111.36341, 30.032578]
      ]
    ]
  ]
})
// 开始求差
const geometry = GeometryEngine.difference(polygon1, polygon2)
console.log("区和多区求差：", geometry)

多区和圆形求差

// ES5引入方式
const { MultiPolygon, Circle, GeometryEngine } = zondy.geometry
// ES6引入方式
import { MultiPolygon, Circle,GeometryEngine } from "@mapgis/webclient-common"
// 构造多区几何
const polygon = new MultiPolygon({
  coordinates: [
    [
      [
        [108.36341, 29.032578],
        [110.13094, 29.032578],
        [110.13094, 33.273224],
        [108.36341, 33.273224],
        [108.36341, 29.032578]
      ]
    ],
    [
      [
        [111.36341, 29.032578],
        [116.13094, 29.032578],
        [116.13094, 33.273224],
        [111.36341, 33.273224],
        [111.36341, 29.032578]
      ]
    ]
  ]
})
// 构造圆几何
const circle = new Circle({
  center: [112.247175, 31.152901],
  radius: 2
})
// 开始求差
const geometry = GeometryEngine.difference(polygon, circle)
console.log("多区和圆求差：", geometry)

矩形和圆求差

// ES5引入方式
const { Extent, Circle, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Extent, Circle,GeometryEngine } from "@mapgis/webclient-common"
// 构造矩形对象
const extent = new Extent({
  xmin: 108.36341,
  ymin: 29.032578,
  xmax: 116.13094,
  ymax: 33.273224
})
// 构造圆形对象
const circle = new Circle({
  center: [112.247175, 31.152901],
  radius: 2
})
// 开始求差
const geometry = GeometryEngine.difference(extent, circle)
console.log("矩形和圆求差：", geometry)

# static disjoint(geometry1opt, geometry2opt)

参数:

示例

是否相离

// ES5引入方式
const { LineString, Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, Polygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造线几何对象
const line = new LineString({
  coordinates: [
    [113, 28],
    [113, 34]
  ]
})
// 构造区几何对象
const polygon = new Polygon({
  coordinates: [
    [
      [108, 30],
      [115, 30],
      [115, 33],
      [108, 33],
      [108, 30]
    ],
    [
      [110, 31],
      [113, 31],
      [113, 32],
      [110, 32],
      [110, 31]
    ]
  ]
})
// 开始求交
const isIntersect = GeometryEngine.disjoint(line, polygon)
console.log("是否相离:", isIntersect)

# static distance(geometry1, geometry2, unit)

参数:

示例

点和点求距离

// ES5引入方式
const { Point, GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine, Point } from "@mapgis/webclient-common"
// 点和点求距离
const point1 = new Point({
  coordinates: [1, 1]
})
const point2 = new Point({
  coordinates: [2, 1]
})
// 可以不传递单位，不传递时默认单位为 "kilometers"
const pointDistance = GeometryEngine.distance(point1, point2);
console.log("点和点求距离:", pointDistance)
// 可以传单位，如传入单位 'miles'
const pointDistance2 = GeometryEngine.distance(point1, point2, "miles")
console.log("点和点求距离(设置单位为"miles"):", pointDistance)

点和线求距离

// ES5引入方式
const { Point, LineString, GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine, Point, LineString } from "@mapgis/webclient-common"
// 点和线求距离
const point1 = new Point({
  coordinates: [100.0, 100.0]
})
const lineString = new LineString({
  coordinates: [
       [100.0, 200.0],
       [101.0, 201.0],
       [103.0, 203.0],
     ],
})
const pointToLineDistance = GeometryEngine.distance(point1, lineString);
console.log("点和线求距离:", pointToLineDistance)

点和面求距离

// ES5引入方式
const { Point, Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine, Point, Polygon } from "@mapgis/webclient-common"
// 点和面求距离
const point1 = new Point({
  coordinates: [100.0, 100.0]
})
const polygon = new Polygon({
   coordinates: [
     [
       [100.0, 0.0],
       [101.0, 0.0],
       [101.0, 1.0],
       [100.0, 1.0],
       [100.0, 0.0],
     ],
   ],
 });
const pointToPolygonDistance = GeometryEngine.distance(point1, polygon);
console.log("点和面求距离:", pointToPolygonDistance)

# static equals(geometry1opt, geometry2opt)

参数:

示例

判断几何是否相等

const isEquals = GeometryEngine.equals(new Point({
  coordinates: [1, 10]
}), new Point({
  coordinates: [1, 10]
}))
console.log("点和点是否相同：", isEquals)

# static geodesicLength(geometryopt, unitopt)

参数:

# static getAngleFromPoints(pointA, pointB, pointC)

参数:

示例

计算三点之间的夹角

// ES5引入方式
const { GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine } from "@mapgis/webclient-common"
// 计算三点之间的夹角
const angle = GeometryEngine.getAngleFromPoints([1, 2], [1, 1], [2, 1])

# static getArcFromGeometry(options)

参数:

示例

通过几何中的三点弧段数据，构造离散后的几何对象

// ES5引入方式
const { LineString, SpatialReference, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, SpatialReference, GeometryEngine } from "@mapgis/webclient-common"
// 构造一个线几何，其他几何对象同线几何对象
const line = new LineString({
  // 几何坐标点
  coordinates:  [
        [
          64.15012768690451,
          89.23584703643573
        ],
        [
          85.69715379735212,
          62.63186581843408
        ],
        [
          92.51304981188144,
          62.851733431806025
        ],
        [
          92.51304981188144,
          62.851733431806025
        ],
        [
          64.15012768690451,
          89.23584703643573
        ]
   ],
  // 几何的参考系，默认是4326，非4326坐标系请指定参考系
  spatialReference: new SpatialReference('EPSG:4326')
})
// 通过几何中的三点弧段数据，构造离散后的几何对象
const arcLine = GeometryEngine.getArcFromGeometry({
  // 几何对象
  geometry: line,
  // 弧段信息参数，必填项
  arcInfo: [
    {
      "centerPointIndex": 1,
      "ringIndex": 0
    }
  ],
  // 弧段中点的数量
  numberOfPoints: 360
})

# static getCenter(point1, point2, point3, hasZ)

参数:

示例

通过三个点求圆心

// ES5引入方式
const { GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine } from "@mapgis/webclient-common"
// 计算圆心
const center = GeometryEngine.getCenter([1, 2], [2, 1], [1, 0])

# static getCenterOID(geometry)

参数:

# static getEllipseCoordinates(center, semiMajorAxis, semiMinorAxis, number)

参数:

# static getPositionsFromArc(options)

参数:

示例

通过三点弧段构造一组离散的点坐标

// ES5引入方式
const { SpatialReference, GeometryEngine } = zondy.geometry
// ES6引入方式
import { SpatialReference, GeometryEngine } from "@mapgis/webclient-common"
// 将弧段打散为离散点
const arc3Path = GeometryEngine.getPositionsFromArc({
  // 弧段上的第一个点，弧段的起点
  point1: [1, 2],
  // 弧段上的第二个点，弧段穿过的点
  point2: [2, 1],
  // 弧段上的第二个点，弧段的终点
  point3: [1, 0],
  // 弧段中点的数量
  numberOfPoints: 360,
  // 弧段的参考系，默认是4326，非4326坐标系请指定参考系
  spatialReference: new SpatialReference('EPSG:4326')
})

# static intersect(geometry1, geometry2)

参数:

# static intersects(geometry1opt, geometry2opt)

参数:

示例

线和区求交

// ES5引入方式
const { LineString, Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, Polygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造线几何对象
const line = new LineString({
  coordinates: [
    [113, 28],
    [113, 34]
  ]
})
// 构造区几何对象
const polygon = new Polygon({
  coordinates: [
    [
      [108, 30],
      [115, 30],
      [115, 33],
      [108, 33],
      [108, 30]
    ],
    [
      [110, 31],
      [113, 31],
      [113, 32],
      [110, 32],
      [110, 31]
    ]
  ]
})
// 开始求交
const isIntersect = GeometryEngine.intersects(line, polygon)
console.log("是否相交:", isIntersect)

点和区求交

// ES5引入方式
const { Point, Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Point, Polygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造点几何对象
const point = new Point({
  coordinates: [112, 32]
})
// 构造区几何对象
const polygon = new Polygon({
  coordinates: [
    [
      [108, 30],
      [115, 30],
      [115, 33],
      [108, 33],
      [108, 30]
    ]
  ]
})
// 开始求交
const isIntersect = GeometryEngine.intersects(point, polygon)
console.log("是否相交:", isIntersect)

区和多区求交

// ES5引入方式
const { Polygon, MultiPolygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Polygon, MultiPolygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造区几何对象
const polygon1 = new Polygon({
  coordinates: [
    [
      [108, 32],
      [112, 32],
      [112, 34],
      [108, 34],
      [108, 32]
    ]
  ]
})
// 构造多区几何对象
const polygon2 = new MultiPolygon({
  coordinates: [
    [
      [
        [108, 33],
        [112, 33],
        [112, 35],
        [108, 35],
        [108, 33]
      ]
    ],
    [
      [
        [114, 32],
        [115, 32],
        [115, 34],
        [114, 34],
        [114, 32]
      ]
    ]
  ]
})
// 开始求交
const isIntersect = GeometryEngine.intersects(polygon1, polygon2)
console.log("是否相交:", isIntersect)

矩形和圆形求交

// ES5引入方式
const { Extent, Circle, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Extent, Circle, GeometryEngine } from "@mapgis/webclient-common"
// 构造矩形几何对象
const extent = new Extent({
  xmin: 108,
  ymin: 33,
  xmax: 115,
  ymax: 34
})
// 构造圆形几何对象
const circle = new Circle({
  center: [113, 32],
  radius: 4
})
// 开始求交
const isIntersect = GeometryEngine.intersects(extent, circle)
console.log("是否相交:", isIntersect)

几何求交 - 自定义参考系

// ES5引入方式
const { Polygon, Circle, SpatialReference, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Polygon, Circle, SpatialReference, GeometryEngine } from "@mapgis/webclient-common"
// 构造区几何对象
const polygon = new Polygon({
  coordinates: [
    [
      [0, 3226025],
      [698545, 3226025],
      [698545, 3685076],
      [0, 3685076],
      [0, 3226025]
    ],
    [
      [100000, 3326025],
      [598545, 3326025],
      [598545, 3485076],
      [100000, 3485076],
      [100000, 3326025]
    ]
  ],
  // 此处要指定坐标系
  spatialReference: new SpatialReference({
    wkid: 4547
  })
})
// 构造圆几何对象
const circle = new Circle({
  center: [245257.10778559791, 3212885.1836444484],
  radius: 400000,
  // 此处要指定坐标系
  spatialReference: new SpatialReference({
    wkid: 4547
  })
})
// 开始求交
const isIntersect = GeometryEngine.intersects(circle, polygon)
console.log("是否相交:", isIntersect)

# static isSimple(geometry)

参数:

示例

对线几何进行拓扑检查

// ES5引入方式
const { LineString, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, GeometryEngine } from "@mapgis/webclient-common"
// 构造线几何对象
const line = new LineString({
  coordinates: [
    [108.36341, 29.032578],
    [116.13094, 29.032578],
    [112.13094, 33.273224],
    [112.13094, 28.273224]
  ]
})
// 对线几何进行拓扑检查
const isSimple = GeometryEngine.isSimple(line)
console.log("是否通过检查:", isSimple)

对多线几何进行拓扑检查

// ES5引入方式
const { MultiLineString, GeometryEngine } = zondy.geometry
// ES6引入方式
import { MultiLineString, GeometryEngine } from "@mapgis/webclient-common"
// 构造多线几何对象
const line = new MultiLineString({
  coordinates: [
    [
      [108.36341, 29.032578],
      [116.13094, 29.032578]
    ],
    [
      [112.13094, 33.273224],
      [112.13094, 28.273224]
    ]
  ]
})
// 对多线几何进行拓扑检查
const isSimple = GeometryEngine.isSimple(line)
console.log("是否通过检查:", isSimple)

对区几何进行拓扑检查

// ES5引入方式
const { Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Polygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造区几何对象
const polygon = new Polygon({
  coordinates: [
    [
      [108.36341, 29.032578],
      [116.13094, 29.032578],
      [112.13094, 33.273224],
      [112.13094, 28.273224],
      [108.36341, 29.032578]
    ]
  ]
})
// 对区几何进行拓扑检查
const isSimple = GeometryEngine.isSimple(polygon)
console.log("是否通过检查:", isSimple)

对多区几何进行拓扑检查

// ES5引入方式
const { Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Polygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造多区几何对象
const multiPolygon = new MultiPolygon({
  coordinates: [
    [
      [
        [108.36341, 29.032578],
        [112.13094, 29.032578],
        [112.13094, 33.273224],
        [108.36341, 33.273224],
        [108.36341, 29.032578]
      ]
    ],
    [
      [
        [112.13094, 29.032578],
        [114.13094, 29.032578],
        [114.13094, 33.273224],
        [112.13094, 33.273224],
        [112.13094, 29.032578]
      ]
    ]
  ]
})
// 对区几何进行拓扑检查
const isSimple = GeometryEngine.isSimple(multiPolygon)
console.log("是否通过检查:", isSimple)

# static nearestCoordinate(geometry, inputPoint)

参数:

示例

线到目标点最近点

// ES5引入方式
const { Point, LineString, GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine, Point, LineString } from "@mapgis/webclient-common"
// inputPoint
 const inputPoint = new Point({
   coordinates: [112, 30],
 });
 // geometry  lineString
 const lineString = new LineString({
   coordinates: [
     [108, 32],
     [115, 32],
   ],
 });
 // 线到目标点最近点
 const pointToLineString = GeometryEngine.nearestCoordinate(
   lineString,
   inputPoint
 );
 console.log("线到目标点最近点：", pointToLineString);

区到目标点最近点

// ES5引入方式
const { Point, Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine, Point, Polygon } from "@mapgis/webclient-common"
// inputPoint
 const inputPoint = new Point({
   coordinates: [100, 30],
 });
 // geometry  Polygon
 const polygon = new Polygon({
   coordinates: [
     [
       [105.0, 35.0],
       [110.0, 35.0],
       [110.0, 36.0],
       [105.0, 36.0],
       [105.0, 35.0],
     ],
   ],
 });
 // 区到目标点最近点
 const pointToPolygon = GeometryEngine.nearestCoordinate(
   polygon,
   inputPoint
 );
 console.log("区到目标点最近点：", pointToPolygon);

# static overlaps(geometry1, geometry2)

参数:

示例

几何是否重叠

// ES5引入方式
const { LineString, Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, Polygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造线几何对象
const line = new LineString({
  coordinates: [
    [113, 28],
    [113, 34]
  ]
})
// 构造区几何对象
const polygon = new Polygon({
  coordinates: [
    [
      [108, 30],
      [115, 30],
      [115, 33],
      [108, 33],
      [108, 30]
    ],
    [
      [110, 31],
      [113, 31],
      [113, 32],
      [110, 32],
      [110, 31]
    ]
  ]
})
// 开始计算是否重叠
const isIntersect = GeometryEngine.overlaps(line, polygon)
console.log("是否重叠:", isIntersect)

# static planarArea(geometry, unitopt)

参数:

示例

计算区(不带洞)面积

// ES5引入方式
const { Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine, Polygon, LengthUnit } from "@mapgis/webclient-common"
// 初始化区几何
const polygon = new Polygon({
  coordinates: [
      [
          [100, 30],
          [110, 30],
          [110, 40],
          [100, 40],
          [100, 30]
      ]
  ]
})
// 计算区几何面积
const area = GeometryEngine.planarArea(polygon)

计算区(带洞)面积

// ES5引入方式
const { Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine, Polygon, LengthUnit } from "@mapgis/webclient-common"
// 初始化区几何 - 带洞
const polygon = new Polygon({
  coordinates: [
    [
      [0, 30],
      [140, 30],
      [140, 40],
      [0, 40],
      [0, 30]
    ],
    [
      [10, 30],
      [20, 30],
      [20, 40],
      [10, 40],
      [10, 30]
    ],
    [
      [30, 30],
      [40, 30],
      [40, 40],
      [30, 40],
      [30, 30]
    ]
  ]
})
// 计算区几何面积
const area = GeometryEngine.planarArea(polygon)

计算多区面积

// ES5引入方式
const { MultiPolygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine, MultiPolygon, LengthUnit } from "@mapgis/webclient-common"
//多区几何
const multiPolygon = new MultiPolygon({
  coordinates: [
      [
        [
          [10, 30],
          [20, 30],
          [20, 40],
          [10, 40],
          [10, 30]
        ]
      ],
      [
        [
          [30, 30],
          [40, 30],
          [40, 40],
          [30, 40],
          [30, 30]
        ]
      ]
  ]
})
// 计算区几何面积
const Area = GeometryEngine.planarArea(multiPolygon)

计算圆面积

// ES5引入方式
const { Circle, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Circle, LengthUnit, GeometryEngine } from "@mapgis/webclient-common"
//圆几何
const circle = new Circle({
  center: [0, 0],
  radius: 10
})
// 计算圆几何面积
const area = GeometryEngine.planarArea(circle)

计算矩形面积

// ES5引入方式
const { Extent, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Extent, LengthUnit, GeometryEngine } from "@mapgis/webclient-common"
//矩形几何
const extent = new Extent({
  xmin: 0,
  ymin: 0,
  xmax: 2,
  ymax: 2
})
// 计算矩形几何面积
const area = GeometryEngine.planarArea(extent)

# static planarLength(geometryopt, unitopt)

参数:

示例

计算几何长度

// ES5引入方式
const { LineString, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, GeometryEngine } from "@mapgis/webclient-common"
// 初始化一个线对象
const line = new LineString({
  coordinates: [
    [0, 1],
    [0, 2]
  ]
})
// 计算几何长度
const length = GeometryEngine.planarLength(line)

计算几何周长

// ES5引入方式
const { Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Polygon, GeometryEngine } from "@mapgis/webclient-common"
// 初始化一个区对象
const polygon = new Polygon({
  coordinates: [
    [
      [0, 0],
      [0, 1],
      [1, 1],
      [0, 1],
      [0, 0]
    ]
  ]
})
// 计算几何周长
const length = GeometryEngine.planarLength(polygon)

# static rotate(geometry, angle, rotationOrigin)

参数:

示例

旋转多点

// ES5引入方式
const { MultiPoint, GeometryEngine } = zondy.geometry
// ES6引入方式
import { MultiPoint, GeometryEngine } from "@mapgis/webclient-common"
// 构造多点几何
const multiPoint = new MultiPoint({
  coordinates: [
    [108.36341, 29.032578],
    [112.13094, 29.032578],
    [112.13094, 33.273224]
  ]
})
// 执行旋转操作
const rotateGeometry = GeometryEngine.rotate(multiPoint, 10)

<caption id='rotate2'><h5>旋转区</h5></caption>
// ES5引入方式
const { Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Polygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造区几何
const polygon = new Polygon({
  coordinates: [
    [
      [108.36341, 29.032578],
      [116.13094, 29.032578],
      [116.13094, 33.273224],
      [108.36341, 33.273224],
      [108.36341, 29.032578],
    ]
  ]
})
// 执行旋转操作
const rotateGeometry = GeometryEngine.rotate(polygon, 10)

旋转多区

// ES5引入方式
const { MultiPolygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { MultiPolygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造多区几何
const polygon = new MultiPolygon({
  coordinates: [
    [
      [
        [108.36341, 29.032578],
        [112.13094, 29.032578],
        [112.13094, 33.273224],
        [108.36341, 33.273224],
        [108.36341, 29.032578],
      ]
    ],
    [
      [
        [113.36341, 29.032578],
        [116.13094, 29.032578],
        [116.13094, 33.273224],
        [113.36341, 33.273224],
        [113.36341, 29.032578],
      ]
    ]
  ]
})
// 执行旋转操作
const rotateGeometry = GeometryEngine.rotate(polygon, 10)

旋转线

// ES5引入方式
const { LineString, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, GeometryEngine } from "@mapgis/webclient-common"
// 构造线几何
const line = new LineString({
  coordinates: [
    [108.36341, 29.032578],
    [116.13094, 29.032578],
    [116.13094, 33.273224],
    [108.36341, 33.273224]
  ]
})
// 执行旋转操作
const rotateGeometry = GeometryEngine.rotate(line, 10)

旋转多线

// ES5引入方式
const { MultiLineString, GeometryEngine } = zondy.geometry
// ES6引入方式
import { MultiLineString, GeometryEngine } from "@mapgis/webclient-common"
// 构造多线几何
const line = new MultiLineString({
  coordinates: [
    [
      [108.36341, 29.032578],
      [116.13094, 29.032578]
    ],
    [
      [116.13094, 33.273224],
      [108.36341, 33.273224]
    ]
  ]
})
// 执行旋转操作
const rotateGeometry = GeometryEngine.rotate(line, 10)

旋转矩形

// ES5引入方式
const { Extent, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Extent, GeometryEngine } from "@mapgis/webclient-common"
// 构造矩形几何
const extent = new Extent({
  xmin: 108.36341,
  ymin: 29.032578,
  xmax: 112.13094,
  ymax: 33.273224
})
// 执行旋转操作
const rotateGeometry = GeometryEngine.rotate(extent, 10)

旋转圆形

// ES5引入方式
const { Circle, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Circle, GeometryEngine } from "@mapgis/webclient-common"
// 构造圆形几何
const circle = new Circle({
  center: [108.36341, 29.032578],
  radius: 3
})
// 执行旋转操作
const rotateGeometry = GeometryEngine.rotate(circle, 10)

旋转区 - 自定义坐标系

// ES5引入方式
const { Polygon, SpatialReference, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Polygon, SpatialReference, GeometryEngine } from "@mapgis/webclient-common"
// 构造区几何
const polygon = new Polygon({
 coordinates: [
   [
     [0, 3226025],
     [698545, 3226025],
     [698545, 3685076],
     [0, 3685076],
     [0, 3226025]
   ]
 ],
 // 一定要指定坐标系
 spatialReference: new SpatialReference({
   wkid: 4547
 })
})
// 执行旋转操作
const rotateGeometry = GeometryEngine.rotate(polygon, 10)

绕点旋转 - 区

// ES5引入方式
const { Polygon, Point, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Polygon, Point, GeometryEngine } from "@mapgis/webclient-common"
// 构造区几何
const polygon = new Polygon({
 coordinates: [
   [
     [108.36341, 29.032578],
     [116.13094, 29.032578],
     [116.13094, 33.273224],
     [108.36341, 33.273224],
     [108.36341, 29.032578]
   ]
 ]
})
// 设置旋转中心点
const rotatePoint = new Point({
  coordinates: [108.36341, 29.032578]
})
// 执行旋转操作
const rotateGeometry = GeometryEngine.rotate(polygon, 10, rotatePoint)

绕点旋转 - 点

// ES5引入方式
const { Point, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Point, GeometryEngine } from "@mapgis/webclient-common"
// 构造点几何
const point = new Point({
  coordinates: [
    [108.36341, 29.032578]
  ]
})
// 设置旋转中心点
const rotatePoint = new Point({
  coordinates: [112.13094, 33.273224]
})
// 执行旋转操作
const rotateGeometry = GeometryEngine.rotate(point, 10, rotatePoint)

# static simplify(geometry)

参数:

# static touches(geometry1, geometry2)

参数:

示例

线和点相邻

// ES5引入方式
const { Point, LineString, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Point, LineString, GeometryEngine } from "@mapgis/webclient-common"
// 构造线对象
const line1 = new LineString({
  coordinates: [
    [107.36341, 31.032578],
    [110, 31.032578],
    [117.13094, 31.032578],
    [107.36341, 31.032578],
  ]
})
// 构造点对象
const point = new Point({
  coordinates: [107.36341, 31.032578],
});
// 开始判断相邻
const isTouch = GeometryEngine.touches(line1, point)
console.log("线和点是否相邻:", isTouch)

多线和多点相邻

// ES5引入方式
const { MultiPoint, MultiLineString, GeometryEngine } = zondy.geometry
// ES6引入方式
import { MultiPoint, MultiLineString, GeometryEngine } from "@mapgis/webclient-common"
// 构造多线对象
 const multiLineString = new MultiLineString({
  coordinates: [
    [
      [112, 31],
      [112, 33],
    ],
    [
      [113, 31],
      [113, 33],
    ],
  ]
})
// 构造多点对象
   const multiPoint = new MultiPoint({
     coordinates: [
       [113, 32],
       [113, 31],
     ],
   });
// 开始判断相邻
const isTouch = GeometryEngine.touches(multiLineString,multiPoint)
console.log("多线和多点是否相邻:", isTouch)

区和线相邻

// ES5引入方式
const { LineString, Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { LineString, Polygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造区对象
const polygon = new Polygon({
  coordinates: [
    [
      [108, 30],
      [115, 30],
      [115, 33],
      [108, 33],
      [108, 30],
    ],
    [
      [110, 31],
      [113, 31],
      [113, 32],
      [110, 32],
      [110, 31],
    ],
  ]
})
// 构造线对象
const line = new LineString({
  coordinates: [
    [105, 30],
    [108, 32],
  ]
})
// 开始判断相邻
const isTouch = GeometryEngine.touches(polygon, line)
console.log("区和线是否相邻:", isTouch)

多区和区相邻

// ES5引入方式
const { MultiPolygon, Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { MultiPolygon, Polygon, GeometryEngine } from "@mapgis/webclient-common"
// 构造多区对象
 const multiPolygon = new MultiPolygon({
     coordinates: [
       [
         [
           [105.0, 35.0],
           [110.0, 35.0],
           [110.0, 36.0],
           [105.0, 36.0],
           [105.0, 35.0],
         ],
       ],
       [
         [
           [108, 30],
           [115, 30],
           [115, 33],
           [108, 33],
           [108, 30],
         ],
         [
           [110, 31],
           [113, 31],
           [113, 32],
           [110, 32],
           [110, 31],
         ],
       ],
     ],
   });
// 构造区对象
const polygon = new Polygon({
  coordinates: [
    [
      [110, 33],
      [113, 33],
      [113, 37],
      [110, 37],
      [110, 33],
    ],
  ]
})
// 开始判断相邻
const isTouch = GeometryEngine.touches( multiPolygon, polygon)
console.log("多区是否和区相邻:", isTouch)

圆和圆相邻

// ES5引入方式
const { Circle, GeometryEngine } = zondy.geometry
// ES6引入方式
import { Circle, GeometryEngine } from "@mapgis/webclient-common"
// 构造圆对象
 const circle1 = new Circle({
     // 中心点
     center: [113, 34],
     // 半径
     radius: 1,
   });
// 构造圆对象
 const circle2 = new Circle({
   // 中心点
   center: [115, 34],
   // 半径
   radius: 2,
 });
// 开始判断相邻
const isTouch = GeometryEngine.touches(circle1, circle2)
console.log("圆和圆是否相邻:", isTouch)

# static union(geometries)

参数:

示例

点和点求并

// ES5引入方式
const { Point, GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine, Point } from "@mapgis/webclient-common"
// 点和点求并
const point1 = new Point({
  coordinates: [1, 1]
})
const point2 = new Point({
  coordinates: [2, 1]
})
const point3 = new Point({
  coordinates: [3, 1, 100]
})
const union = GeometryEngine.union([point1, point2, point3])
console.log("点和点求并:", union)

点和多点求并

// ES5引入方式
const { Point, MultiPoint, GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine, Point, MultiPoint } from "@mapgis/webclient-common"
// 点和多点求并
const point1 = new Point({
  coordinates: [1, 1]
})
const point2 = new MultiPoint({
  coordinates: [
    [2, 1],
    [3, 1]
  ]
})
const union = GeometryEngine.union([point1, point2])
console.log("点和多点求并:", union)

多点和多点求并

// ES5引入方式
const { Point, MultiPoint, GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine, Point, MultiPoint } from "@mapgis/webclient-common"
// 多点和多点求并
const point1 = new MultiPoint({
  coordinates: [
    [2, 1],
    [3, 1],
    [3, 3, 4]
  ]
})
const point2 = new MultiPoint({
  coordinates: [
    [2, 1],
    [3, 1]
  ]
})
const union = GeometryEngine.union([point1, point2])
console.log("多点和多点求并:", union)

区和区求并

// ES5引入方式
const { Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine, Polygon } from "@mapgis/webclient-common"
// 区和区求并
const polygon1 = new Polygon({
  coordinates: [
    [
      [-82.574787, 35.594087],
      [-82.574787, 35.615581],
      [-82.545261, 35.615581],
      [-82.545261, 35.594087],
      [-82.574787, 35.594087]
    ]
  ]
})
const polygon2 = new Polygon({
  coordinates: [
    [
      [-82.560024, 35.585153],
      [-82.560024, 35.602602],
      [-82.52964, 35.602602],
      [-82.52964, 35.585153],
      [-82.560024, 35.585153]
    ]
  ]
})
const union = GeometryEngine.union([polygon1, polygon2])
console.log("区和区求并:", union)

区和带洞区求并

// ES5引入方式
const { Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine, Polygon } from "@mapgis/webclient-common"
// 区和带洞区求并
const polygon1 = new Polygon({
  coordinates: [
    [
      [100, 30],
      [110, 30],
      [110, 40],
      [100, 40],
      [100, 30]
    ]
  ]
})
const polygon2 = new Polygon({
  coordinates: [
    [
      [105, 30],
      [120, 30],
      [120, 40],
      [105, 40],
      [105, 30]
    ],
    [
      [108, 35],
      [116, 35],
      [116, 36],
      [108, 36],
      [108, 35]
    ]
  ]
})
const union = GeometryEngine.union([polygon1, polygon2])
console.log("区和带洞区求并:", union)

带洞区和带洞区的求并

// ES5引入方式
const { Polygon, GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine, Polygon } from "@mapgis/webclient-common"
// 带洞区和带洞区的求并
const polygon1 = new Polygon({
   coordinates: [
     [
       [100, 30],
       [110, 30],
       [110, 40],
       [100, 40],
       [100, 30]
     ],
     [
       [103, 35],
       [106, 35],
       [106, 36],
       [103, 36],
       [103, 35]
     ]
   ]
 })
 const polygon2 = new Polygon({
   coordinates: [
     [
       [105, 30],
       [120, 30],
       [120, 40],
       [105, 40],
       [105, 30]
     ],
     [
       [108, 35],
       [116, 35],
       [116, 36],
       [108, 36],
       [108, 35]
     ]
   ]
 })
 const union = GeometryEngine.union([polygon1, polygon2])
 console.log("带洞区和带洞区的求并:", union)

# static within(innerGeometry, outerGeometry)

参数:

示例

判断是否包含

// ES5引入方式
const { Polygon, Point, GeometryEngine } = zondy.geometry
// ES6引入方式
import { GeometryEngine, Polygon, Point } from "@mapgis/webclient-common"
// 初始点几何，可以是任意几何
const point = new Point({
  coordinates: [1, 1]
})
// 初始化区几何，可以是任意几何
const polygon = new Polygon({
  coordinates: [
    [
      [1, 0],
      [10, 0],
      [10, 20],
      [1, 20],
      [1, 0]
    ]
  ]
})
// 判断点几何是否被区几何对象包含
const isContains = GeometryEngine.within(polygon, point)
console.log("点几何是否被区几何对象包含:", isContains)