import * as T from '@turf/turf'
import Evented from '../Evented'
import { defaultValue, defined, isNull, Log } from '../../util'
import Zondy from '../Zondy'
import { GeometryType, IGSGeometryType } from '../enum'
import { createGeometry, createGeometryByGeoJSON } from './Utiles'
import SpatialReference from './SpatialReference'
import { Polygon, GeometryEngine } from './index'
/**
* 几何图形对象基类
* <br><br>[ES5引入方式]：<br/>
* Zondy.Geometry.Geometry() <br/>
* [ES6引入方式]：<br/>
* import { Geometry } from "@mapgis/webclient-common" <br/>
* <br/>
* @class Geometry
* @extends Evented
* @moduleEX GeometryModule
* @param {Object} options 构造参数
* @param {SpatialReference} [options.spatialReference = new Zondy.SpatialReference('EPSG:4326')] 几何点的空间参考系，默认4326
*/
class Geometry extends Evented {
constructor(options) {
super(options)
// 构造几何对象
options = defaultValue(options, {})
/**
* 几何点的空间参考系
* @member {SpatialReference} Geometry.prototype.spatialReference
*/
this.spatialReference = defaultValue(
SpatialReference.fromJSON(options.spatialReference),
new SpatialReference('EPSG:4326')
)
/**
* 是否含有z坐标
* @readonly
* @member {Boolean} Geometry.prototype.hasZ
*/
this.hasZ = false
/**
* 几何类型
* @readonly
* @member {GeometryType} GeometryType.prototype.type
*/
this.type = GeometryType.geometry
}
static fromGeoJSON(json) {
return createGeometryByGeoJSON(json)
}
/**
* 克隆几何对象
* @return {Geometry} 克隆后的几何对象
*/
clone() {
return new Geometry(this.toJSON())
}
/**
* 通过一个JSON对象创建一个几何对象
* @param {Object} json JSON对象
* @return {Geometry} 几何对象
*
* @example <caption><h5 id='fromJSON'>通过一个JSON对象创建一个几何对象</h7></caption>
* // ES5引入方式
* const { Geometry } = Zondy
* const { GeometryType } = Zondy.Enum
* // ES6引入方式
* import { Geometry, GeometryType } from "@mapgis/webclient-common"
* // 通过json构造一个几何对象
* const polygon = Geometry.fromJSON({
* // 注意必须传入一个几何类型
* type: GeometryType.polygon,
* coordinates: [
* [
* [113, 29],
* [114, 29],
* [114, 30],
* [113, 30],
* [113, 29]
* ]
* ]
* })
*/
static fromJSON(json) {
json = defaultValue(json, {})
return createGeometry(json)
}
/**
* 导出为json对象
* @return {Object} json对象
*/
toJSON() {
return {
spatialReference:
this.spatialReference instanceof SpatialReference
? this.spatialReference.toJSON()
: this.spatialReference,
hasZ: this.hasZ,
type: this.type
}
}
/**
* 导出为GeoJSON
* @return {Object} GeoJSON对象
* */
toGeoJSON() {
return {
type: this.type,
coordinates: this.coordinates
}
}
/**
* 导入GeoJSON
* @param {Object} GeoJSON Object
* */
fromGeoJSON(geoJSON) {
if (geoJSON || geoJSON.type !== this.type) {
new Error('GeoJSON类型和几何类型不一致')
}
if (defined(this.coordinates)) {
this.coordinates = geoJSON.coordinates
}
}
/**
* 导出为OGC服务要求的xml字符串，子类实现
* @return {String} 字符串
*/
toXML() {
return ''
}
/**
* 返回所对应的GeometryModule型
* @returns {String} GeometryModule型
*/
getType() {
return this.type
}
/**
* 返回IGS所对应的GeometryModule型
* @returns {String} GeometryModule型
*/
getIGSType() {
return IGSGeometryType.geometry
}
/**
* 获取GeometryModule型
* @return {String} GeometryModule型
*/
getGeometryType() {
return this.type
}
/**
* 导出为字符串，子类实现，这里必须是igs要求的字符串
* @return {String} 字符串
*/
toString() {
return ''
}
/**
* 对点数组进行是否为顺时针判断;<br/>
* 支持的参数类型为闭合的二维点数组;<br/>
* 示例如下：<br/>
* <a href='#isClockwise'>[对点数组进行顺时针判断]</a><br/>
* @param {Array} pointArr 点数组
* @return {Boolean} 是否为顺时针
*
* @example <caption><h5 id='isClockwise'>对点数组进行顺时针判断</h5></caption>
* // ES5引入方式
* const { Geometry } = Zondy.Geometry
* // ES6引入方式
* import { Geometry } from "@mapgis/webclient-common"
* // 构造线几何对象
* const pointArr = [
* [112, 30],
* [114, 30],
* [114, 32],
* [112, 30],
* ];
* // 对点数组进行顺时针判断
* const isClockwise = Geometry.isClockwise(pointArr)
* console.log("是否为顺时针:", isClockwise)
* */
static isClockwise(pointArr) {
pointArr = defaultValue(pointArr, undefined)
// 1.先判断入参非空
if (isNull(pointArr)) {
Log.error('geometry1不能为空！')
}
// 2.入参类型检查，必须是数组
if (!(pointArr instanceof Array)) {
Log.error('输入参数类型错误，需要输入点数组！')
}
// 3.入参类型检查，不能是一维数组三维数组，必须是二维数组
for (let i = 0; i < pointArr.length; i++) {
if (!(pointArr[i] instanceof Array)) {
Log.error('输入参数类型错误，需要输入二维数组！')
} else {
for (let j = 0; j < pointArr[i].length; j++) {
if (pointArr[i][j] instanceof Array) {
Log.error('输入参数类型错误，需要输入二维数组！')
}
}
}
}
// 4. 是否为闭合的点检查
if (
!(
pointArr[0].length === pointArr[pointArr.length - 1].length &&
JSON.stringify(pointArr[0]) ===
JSON.stringify(pointArr[pointArr.length - 1])
)
) {
Log.error('输入的点数组必须首尾闭合！')
}
// 6.通过判断点数组
if (!isNull(pointArr)) {
const _clockwiseRing = T.lineString(pointArr)
return T.booleanClockwise(_clockwiseRing)
}
}
/**
* 对入参进行判断处理，构建polygon;<br/>
* 支持的参数类型为闭合的三维点数组(多个ring构成的数组)，不区分顺逆时针;<br/>
* 示例如下：<br/>
* <a href='#fromRings1'>[1、根据入参构建polygon]</a><br/>
* <a href='#fromRings2'>[1、根据入参构建polygon，指定rings坐标系]</a><br/>
* @param {Array} pointArr 点数组
* @param {SpatialReference} spatialReference 几何点的空间参考系，默认4326，非必填，当不是4326时请指定坐标系，方便进行投影转换
* @return {Array} 构建的polygon组成的对象数组
*
* @example <caption><h5 id='fromRings1'>点数组构建polygon</h5></caption>
* // ES5引入方式
* const { Geometry} = Zondy.Geometry
* // ES6引入方式
* import { Geometry } from "@mapgis/webclient-common"
* // 输入三维点数组
* const pointArr = [
* [
* [108, 30],
* [108, 33],
* [115, 33],
* [115, 30],
* [108, 30],
* ],
* [
* [110, 31],
* [113, 31],
* [113, 32],
* [110, 32],
* [110, 31],
* ],
* [
* [110, 20],
* [110, 25],
* [115, 25],
* [115, 20],
* [110, 20],
* ],
* ];
* // 点数组构建polygon
* const fromRings = Geometry.fromRings(pointArr)
* console.log("构建的多边形对象:", fromRings)
*
* @example <caption><h5 id='fromRings2'>指定坐标系的点数组构建polygon</h5></caption>
* // ES5引入方式
* const { Geometry,SpatialReference} = Zondy.Geometry
* // ES6引入方式
* import { Geometry,SpatialReference } from "@mapgis/webclient-common"
* // 输入指定坐标系的点数组
* const pointArr_4547 = [
* [
* [-79450.434008356, 3335318.50110312],
* [-61138.8507993389, 3668785.80194059],
* [593455.16027313, 3653192.25094895],
* [596488.74806744, 3320534.43645214],
* [-79450.434008356, 3335318.50110312],
* ],
* [
* [22192.1178133016, 3441729.02787479],
* [213425.289259696, 3434840.60529103],
* [216463.35881388, 3545788.2250497],
* [27269.5496056064, 3552800.06686639],
* [22192.1178133016, 3441729.02787479],
* ],
* [
* [307007.697900227, 3441729.02787479],
* [500000.000000819, 3441729.02787479],
* [500000.00000081, 3545788.2250497],
* [308973.125268913, 3545788.2250497],
* [307007.697900227, 3441729.02787479],
* ],
* [
* [81149.2212748193, 2217372.5132106],
* [81149.2212748193, 2766426.51455527],
* [600953.408059909, 2766426.51455527],
* [600953.408059909, 2217372.5132106],
* [81149.2212748193, 2217372.5132106],
* ],
* ];
*
* // 创建坐标系
* const spatialReference = new SpatialReference({
* wkid: 4547,
* });
* // 点数组构建polygon
* const fromRings = Geometry.fromRings(pointArr_4547, spatialReference)
* console.log("构建的指定坐标系的多边形对象:", fromRings)
* */
static fromRings(geometry, spatialReference) {
geometry = defaultValue(geometry, undefined)
const _spatialReference = defaultValue(
SpatialReference.fromJSON(spatialReference),
new SpatialReference('EPSG:4326')
)
// 1.先判断入参非空
if (isNull(geometry)) {
Log.error('geometry1不能为空！')
}
// 2.入参类型检查，必须是数组，字符串也要转数组
if (!(geometry instanceof Array)) {
Log.error('输入参数类型错误，需要输入点数组！')
}
// 3.入参类型检查，不能是一维数组四维数组，必须是三维数组
const a = this._multiarr(geometry)
if (a !== 3) {
Log.error('输入参数错误，需要输入三维数组！')
}
let _polygon
// 4.三维数组处理
// 4.1 判断三维数组长度是否为1
if (geometry.length === 1) {
// 多了一层数组的二维数组[[[1,2],[3,4],[5,6],[1,2]]]
const _geometry = geometry[0]
// 检查闭合点
if (
!(
_geometry[0].length === _geometry[_geometry.length - 1].length &&
JSON.stringify(_geometry[0]) ===
JSON.stringify(_geometry[_geometry.length - 1])
)
) {
_geometry.push(_geometry[0])
}
_polygon = new Polygon({
coordinates: [_geometry],
spatialReference: _spatialReference
})
return _polygon
} else {
// 先遍历每个ring
// 用来记录所有ring的数组
const _ringsObjArr = []
// 有多个圈，先遍历每个圈
for (let i = 0; i < geometry.length; i++) {
// 每个圈对象化
const _pointObj = {
geometry: undefined,
area: null,
inner: []
}
// 5.闭合点检查
if (
!(
JSON.stringify(geometry[i][0]) ===
JSON.stringify(geometry[i][geometry[i].length - 1])
)
) {
geometry[i].push(geometry[i][0])
}
// 先 生成polygon
const _geometry = new Polygon({
coordinates: [geometry[i]],
spatialReference: _spatialReference
})
_pointObj.geometry = _geometry
// 计算面积
_pointObj.area = GeometryEngine.planarArea(_geometry)
_ringsObjArr.push(_pointObj)
}
// 在这里得到ring对象的数组 _ringsObjArr
// 用来存放处理好的ring以及他的inner
const stateObj = []
const ringArr = this._processArr(stateObj, _ringsObjArr)
// 开始new
const coords = []
for (let i = 0; i < ringArr.length; i++) {
const coord = [ringArr[i].geometry.coordinates[0]]
// 检查有无内圈
if (ringArr[i].inner.length >= 1) {
ringArr[i].inner.forEach((item) => {
coord.push(item.geometry.coordinates[0])
})
}
coords.push(coord)
}
const polygonObj = []
// 返回polygon组成的Object
for (let i = 0; i < ringArr.length; i++) {
// new polygon
_polygon = new Polygon({
coordinates: coords[i],
spatialReference: _spatialReference
})
polygonObj.push(_polygon)
}
return polygonObj
}
}
/**
* ring 生成 polygon拓扑关系检查
* @param {Array} arr 多维数组
* @return {Array} 返回整理好的对象数组
* */
static _processArr(stateObj, ringsObjArr) {
// 根据面积排序
ringsObjArr.sort((a, b) => {
return b.area - a.area
})
// 得到面积从大到小排序的对象数组 ringsObjArr
// 取第一个
const firstObj = ringsObjArr[0]
// 用来存新的、与第一个ring相离的ring对象
const _newDisjointObjArr = []
// 遍历剩下的
for (let i = 1; i < ringsObjArr.length; i++) {
// 判断第一个和剩下的是否相离
if (GeometryEngine.disjoint(firstObj.geometry, ringsObjArr[i].geometry)) {
// 若相离，作为新数组存入
_newDisjointObjArr.push(ringsObjArr[i])
}
// 若不相离,判断第一个ring是否包含第i个ring
else if (
GeometryEngine.contains(firstObj.geometry, ringsObjArr[i].geometry)
) {
// 若包含，则第一个ring的inner暂存第i个ring
firstObj.inner.push(ringsObjArr[i])
} else {
// 若不相离也不包含，说明存在相交的情况，将其作为外圈放入新数组
_newDisjointObjArr.push(ringsObjArr[i])
}
}
// 第一遍结束,得到第一个ring和他互不相交的n个内圈,以及和第一个ring相离或者相交的其他外圈
// 开始处理第一个ring的所有内圈
if (firstObj.inner.length > 1) {
for (let i = 0; i < firstObj.inner.length; i++) {
// 取第一个
const _one = firstObj.inner[i]
// 在这里，第一个ring的内圈，要做到不相交，不包含，但面和面的包含也是一种相交，因此在判断完相交后要继续判断是否包含
for (let j = i + 1; j < firstObj.inner.length; j++) {
if (
GeometryEngine.intersects(_one.geometry, firstObj.inner[j].geometry)
) {
if (
GeometryEngine.contains(_one.geometry, firstObj.inner[j].geometry)
) {
// 若包含，则需要把这个ring作为一个单独的polygon加入到新数组中，从第一个ring的inner中踢出去
_newDisjointObjArr.push(firstObj.inner[j])
firstObj.inner.splice(j, 1)
// 删除后inner的长度-1，因此j也要-1
j--
} else {
Log.error('输入的几何存在拓扑错误，请检查')
}
}
}
}
}
stateObj.push(firstObj)
if (_newDisjointObjArr.length > 1) {
this._processArr(stateObj, _newDisjointObjArr)
} else if (_newDisjointObjArr.length === 1) {
stateObj.push(_newDisjointObjArr[0])
}
return stateObj
}
/**
* 判断输入数组的维度
* @param {Array} arr 多维数组
* @return {Number} 返回输入数组的维度
* */
static _multiarr(arr) {
const list = []
let num = 1
for (let i = 0; i < arr.length; i++) {
if (arr[i] instanceof Array) {
for (let j = 0; j < arr[i].length; j++) {
list.push(arr[i][j])
}
}
}
if (list.length) {
num = 1
num += this._multiarr(list)
}
return num
}
/**
* fromRings输入参数为字符串时解析字符串
* @param {String} pointStr 多维数组
* @return {Number} 返回输入数组的维度
* */
static _parseString(pointStr) {
const _geometry = []
// *分割每个圈，先把圈剥出来
const _ringsAll = pointStr.split('*')
// 空格分隔每个点
for (let i = 0; i < _ringsAll.length; i++) {
// _ring得到的是以，分割的每个圈的所有坐标点
const _ring = _ringsAll[i].split(' ')
// 在这里还要进行是否是弧段的判断
// 遍历每个ring中的每个元素，如果有#
const _pointsArrStr = []
for (let j = 0; j < _ring.length; j++) {
_pointsArrStr.push(_ring[j].split(','))
if (_ring[j].indexOf('#') > -1) {
_ring[j] = _ring[j].replace('#', '')
_pointsArrStr.splice(j - 1, 2)
// 拼接弧段
const _arc = [
_ring[j - 1].split(','),
_ring[j].split(','),
_ring[j + 1].split(',')
]
_pointsArrStr.push(_arc)
j++
}
}
// _pointsArrStr 用来存放转成number的每圈的坐标
const _pointsArr = []
for (let j = 0; j < _pointsArrStr.length; j++) {
let _pointsLonely
if (_pointsArrStr[j][0] instanceof Array) {
// 有弧段
const _temp = []
for (let k = 0; k < _pointsArrStr[j].length; k++) {
_pointsLonely = _pointsArrStr[j][k].map((item) => {
return Number(item)
})
// 这样可以弧度单独为一个数组
_temp.push(_pointsLonely)
// 这样可以弧度转点
// _pointsArr.push(_pointsLonely)
}
_pointsArr.push(_temp)
} else {
_pointsLonely = _pointsArrStr[j].map((item) => {
return Number(item)
})
_pointsArr.push(_pointsLonely)
}
}
_geometry.push(_pointsArr)
}
return _geometry
}
}
Object.defineProperties(Geometry.prototype, {
/**
* 几何的范围
* @member {Number} Geometry.prototype.extent
* */
extent: {
configurable: false,
get() {
return undefined
}
}
})
export default Geometry
Zondy.Geometry.Geometry = Geometry
