w-gis 1.0.12 → 1.0.13

package/src/calcContours.mjs

@@ -0,0 +1,267 @@
+import each from 'lodash/each'
+import map from 'lodash/map'
+import min from 'lodash/min'
+import max from 'lodash/max'
+import get from 'lodash/get'
+import size from 'lodash/size'
+import isearr from 'wsemi/src/isearr.mjs'
+import { tricontour } from 'd3-tricontour'
+import getArea from './getArea.mjs'
+import getCentroidMultiPolygon from './getCentroidMultiPolygon.mjs'
+import clipMultiPolygon from './clipMultiPolygon.mjs'
+import intersectMultiPolygon from './intersectMultiPolygon.mjs'
+
+
+function calcContours(points, opt = {}) {
+
+    function getContours(pts) {
+
+        //tricontour
+        let tric = tricontour()
+
+        //calc
+        let contours = tric(pts)
+        // console.log('calcContours contours1', contours)
+        // contours = [contours[0], contours[1], contours[2], contours[3]]
+        // console.log('calcContours contours2', contours)
+
+        return contours
+    }
+
+    //containInner
+    let containInner = get(opt, 'containInner', null)
+
+    //clipInner
+    let clipInner = get(opt, 'clipInner', null)
+
+    //clipOuter
+    let clipOuter = get(opt, 'clipOuter', null)
+
+    //valueMin, valueMax
+    let valueMin = points[0][2]
+    let valueMax = points[0][2]
+    for (let i = 1; i < size(points); i++) {
+        let value = points[i][2]
+        if (valueMin > value) {
+            valueMin = value
+        }
+        if (valueMax < value) {
+            valueMax = value
+        }
+    }
+    // console.log('valueMin', valueMin, 'valueMax', valueMax)
+
+    //contours
+    let contours = getContours(points)
+    // console.log('contours', cloneDeep(contours))
+
+    //check
+    if (!isearr(contours)) {
+        // console.log('can not calculate contours', contours)
+        return []
+    }
+    // console.log('contours.length', contours.length)
+
+    //polylines
+    let polylines = map(contours, (v, k) => {
+
+        return {
+            latLngs: v.coordinates,
+            level: v.value,
+            effectArea: getArea(v.coordinates),
+            effectAreaCentroid: getCentroidMultiPolygon(v.coordinates), //要先計算, 否則之後會被相減計算成真實等值區域, 就不是影響區域的中心了
+        }
+    })
+    // console.log('polylines from contours', cloneDeep(polylines))
+
+    //針對可能超出數據區添加polyline
+    if (true) {
+
+        //pmin, pmax
+        let pmin = min(map(polylines, 'level'))
+        let pmax = max(map(polylines, 'level'))
+        // console.log('pmin', pmin, 'pmax', pmax)
+
+        //實際數據有超出contours的最大值, 添加虛擬polyline
+        if (pmax < valueMax) {
+            polylines.push({
+                mode: 'virtualEnd',
+                latLngs: [],
+                level: valueMax,
+                effectArea: 0,
+            })
+        }
+
+        //實際數據有低於contours的最小值, 添加虛擬polyline
+        if (pmin > valueMin) {
+            let pl = {
+                mode: 'virtualStart',
+                latLngs: [],
+                level: valueMin,
+                effectArea: 0,
+            }
+            polylines = [pl, ...polylines]
+        }
+
+    }
+    // console.log('polylines for vartual level', cloneDeep(polylines))
+
+    //若不是於超出數據區新增虛擬polyline, 因tricontour會給出繪圖間距而不是實際資料間距, 故會出現level值大於或小於原數據上下限
+    if (true) {
+        each(polylines, (v, k) => {
+            v.level = Math.min(v.level, valueMax)
+            v.level = Math.max(v.level, valueMin)
+        })
+    }
+    // console.log('polylines for limit level', cloneDeep(polylines))
+
+    //polygonSets, 剔除下1個多邊形區域, 為實際需繪製的等值區
+    let polygonSets = []
+    for (let i = 0; i <= polylines.length - 2; i++) {
+
+        //p0,p1,range
+        let p0 = polylines[i].latLngs
+        let p1 = polylines[i + 1].latLngs
+        let range = {
+            text: `${polylines[i].level} - ${polylines[i + 1].level}`,
+            low: polylines[i].level,
+            up: polylines[i + 1].level,
+        }
+
+        //clipMultiPolygon
+        let latLngs = []
+        latLngs = clipMultiPolygon(p0, p1)
+        if (get(polylines[i], 'mode' === 'virtualStart')) { //若為virtualStart, 則代表直接使用下1個polylines成為等值區域, 方能代表凹陷區
+            latLngs = p1 //因為既有屬性都是取前者, 故若virtualStart係使用後者p1, 就代表全部polygonSet都會有真實effectArea
+        }
+        else {
+            latLngs = clipMultiPolygon(p0, p1)
+        }
+
+        polygonSets.push({
+            ...polylines[i],
+            latLngs,
+            range,
+        })
+    }
+    // console.log('polygonSets from polylines', cloneDeep(polygonSets))
+
+    //polygonsContainInner, 保留指定多polygon以內區域
+    if (true) {
+        let t = []
+        each(polygonSets, (polygonSet, k) => {
+
+            //latLngs
+            let latLngs = null
+            if (isearr(containInner)) {
+
+                //intersectMultiPolygon
+                latLngs = intersectMultiPolygon(polygonSet.latLngs, containInner)
+
+            }
+            else {
+                latLngs = polygonSet.latLngs
+            }
+
+            //check
+            if (size(latLngs) > 0) {
+                t.push({
+                    ...polygonSet,
+                    latLngs,
+                })
+            }
+
+        })
+        polygonSets = t
+    }
+    // console.log('polygonSets for polygonsContainInner', cloneDeep(polygonSets))
+
+    //polygonsClipInner, 剔除指定多polygon以內區域
+    if (true) {
+        let t = []
+        each(polygonSets, (polygonSet, k) => {
+
+            //latLngs
+            let latLngs = null
+            if (isearr(clipInner)) {
+
+                //clipMultiPolygon
+                latLngs = clipMultiPolygon(polygonSet.latLngs, clipInner)
+
+            }
+            else {
+                latLngs = polygonSet.latLngs
+            }
+
+            //check
+            if (size(latLngs) > 0) {
+                t.push({
+                    ...polygonSet,
+                    latLngs,
+                })
+            }
+
+        })
+        polygonSets = t
+    }
+    // console.log('polygonSets for polygonsClipInner', cloneDeep(polygonSets))
+
+    //polygonClipOuter, 剔除指定polygon以外區域
+    if (true) {
+        let t = []
+        each(polygonSets, (polygonSet) => {
+
+            //latLngs
+            let latLngs = null
+            if (isearr(clipOuter)) {
+
+                //intersectMultiPolygon
+                latLngs = intersectMultiPolygon(polygonSet.latLngs, clipOuter)
+
+            }
+            else {
+                latLngs = polygonSet.latLngs
+            }
+
+            //check
+            if (size(latLngs) > 0) {
+                t.push({
+                    ...polygonSet,
+                    latLngs,
+                })
+            }
+
+        })
+        polygonSets = t
+    }
+    // console.log('polygonSets for polygonClipOuter', cloneDeep(polygonSets))
+
+    //center
+    if (true) {
+        let areaMax = 0
+        let areaInd = null
+        let areaCentroid = null
+        each(polygonSets, (polygonSet, k) => {
+            if (areaMax < polygonSet.effectArea) {
+                areaInd = k
+                areaMax = polygonSet.effectArea
+                areaCentroid = polygonSet.effectAreaCentroid
+            }
+        })
+        if (areaInd === null) {
+            // console.log('can not calculate centroid of contour', polygonSets)
+            return []
+        }
+
+        //add center
+        each(polygonSets, (polygonSet, k) => {
+            polygonSets[k].center = areaCentroid
+        })
+
+    }
+
+    return polygonSets
+}
+
+
+export default calcContours

package/src/clipMultiPolygon.mjs

@@ -0,0 +1,15 @@
+import turf from './getTurf.mjs'
+import toMultiPolygon from './toMultiPolygon.mjs'
+import distilMultiPolygon from './distilMultiPolygon.mjs'
+
+
+function clipMultiPolygon(pgs, pgsCut) {
+
+    //difference
+    let r = turf.difference(turf.helpers.multiPolygon(toMultiPolygon(pgs)), turf.helpers.multiPolygon(toMultiPolygon(pgsCut)))
+
+    return distilMultiPolygon(r)
+}
+
+
+export default clipMultiPolygon

package/src/distilMultiPolygon.mjs

@@ -0,0 +1,30 @@
+import get from 'lodash/get'
+import parseGeometryCollection from './parseGeometryCollection.mjs'
+
+
+function distilMultiPolygon(r) {
+    //因turf計算後可能產生多種幾何類型, 例如Polygon,MultiPolygon,LineString,GeometryCollection, 故將全部轉成MultiPolygon後回傳
+
+    //type
+    let type = get(r, 'geometry.type', '')
+
+    //pgNew
+    let pgNew = get(r, 'geometry.coordinates', [])
+
+    if (type === 'Polygon') {
+        return [pgNew]
+    }
+    else if (type === 'MultiPolygon') {
+        return pgNew
+    }
+    else if (type === 'GeometryCollection') {
+        return parseGeometryCollection(r)
+    }
+    else {
+        // console.log('type', type, r)
+        return []
+    }
+}
+
+
+export default distilMultiPolygon

package/src/fixGeometryMultiPolygon.mjs

@@ -0,0 +1,52 @@
+import each from 'lodash/each'
+import filter from 'lodash/filter'
+import cloneDeep from 'lodash/cloneDeep'
+import isernot from 'wsemi/src/isernot.mjs'
+import turf from './getTurf.mjs'
+import invCoordPolygon from './invCoordPolygon.mjs'
+import distilMultiPolygon from './distilMultiPolygon.mjs'
+import invCoordMultiPolygon from './invCoordMultiPolygon.mjs'
+
+
+function fixGeometryMultiPolygon(pgs) {
+
+    function core(pg) {
+
+        //invCoordPolygon, 因為buffer需要輸入正確經緯度才有辦法運算
+        pg = invCoordPolygon(pg)
+
+        //pgt
+        let pgt = turf.polygon(pg)
+
+        //buffer
+        let bf = turf.buffer(pgt, 1, { units: 'kilometers' })
+
+        //distilMultiPolygon, 因buff後可能為多種幾何類型, 故需先統一轉成MultiPolygon
+        let pgsNew = distilMultiPolygon(bf)
+
+        //invCoordMultiPolygon, 變成MultiPolygon後需反轉座標回原始數據之定義方式
+        pgsNew = invCoordMultiPolygon(pgsNew)
+
+        return pgsNew
+    }
+
+    //cloneDeep
+    pgs = cloneDeep(pgs)
+
+    //core
+    let pgsNew = []
+    each(pgs, (pg) => {
+        let r = core(pg) //回傳是MultiPolygon
+        each(r, (v) => {
+            pgsNew.push(v)
+        })
+    })
+
+    //filter
+    pgsNew = filter(pgsNew, isernot)
+
+    return pgsNew
+}
+
+
+export default fixGeometryMultiPolygon

package/src/getArea.mjs

@@ -0,0 +1,20 @@
+import isearr from 'wsemi/src/isearr.mjs'
+import turf from './getTurf.mjs'
+import toMultiPolygon from './toMultiPolygon.mjs'
+
+
+function getArea(pgs) {
+
+    //check
+    if (!isearr(pgs)) {
+        return null
+    }
+
+    //area
+    let r = turf.area(turf.helpers.multiPolygon(toMultiPolygon(pgs)))
+
+    return r
+}
+
+
+export default getArea

package/src/getCenterOfMassMultiPolygon.mjs

@@ -0,0 +1,24 @@
+import get from 'lodash/get'
+import isearr from 'wsemi/src/isearr.mjs'
+import turf from './getTurf.mjs'
+import toMultiPolygon from './toMultiPolygon.mjs'
+
+
+function getCenterOfMassMultiPolygon(pgs) {
+
+    //check
+    if (!isearr(pgs)) {
+        return null
+    }
+
+    //centerOfMass
+    let r = turf.centerOfMass(turf.helpers.multiPolygon(toMultiPolygon(pgs)))
+
+    //pt
+    let pt = get(r, 'geometry.coordinates', [])
+
+    return pt
+}
+
+
+export default getCenterOfMassMultiPolygon

package/src/getCentroidMultiPolygon.mjs

@@ -0,0 +1,24 @@
+import get from 'lodash/get'
+import isearr from 'wsemi/src/isearr.mjs'
+import turf from './getTurf.mjs'
+import toMultiPolygon from './toMultiPolygon.mjs'
+
+
+function getCentroidMultiPolygon(pgs) {
+
+    //check
+    if (!isearr(pgs)) {
+        return null
+    }
+
+    //centroid
+    let r = turf.centroid(turf.helpers.multiPolygon(toMultiPolygon(pgs)))
+
+    //pt
+    let pt = get(r, 'geometry.coordinates', [])
+
+    return pt
+}
+
+
+export default getCentroidMultiPolygon

package/src/getTurf.mjs

@@ -0,0 +1,32 @@
+import isWindow from 'wsemi/src/isWindow.mjs'
+import turfBrowser from './_importTurfBrowser.mjs'
+import turfNode from './_importTurfNode.mjs'
+
+
+let turf = null
+if (isWindow()) {
+    // console.log('use turfBrowser')
+    turf = turfBrowser
+}
+else {
+    // console.log('use turfNode')
+    turf = turfNode
+}
+// console.log('turf', turf)
+
+
+// //turf function
+// let helpers = turf.helpers
+// let { polygon, multiPolygon, lineString } = helpers
+// let area = turf.area
+// let centroid = turf.centroid
+// let centerOfMass = turf.centerOfMass
+// let intersect = turf.intersect
+// let mask = turf.mask
+// let difference = turf.difference
+// let bezierSpline = turf.bezierSpline
+// let buffer = turf.buffer
+// let booleanPointInPolygon = turf.booleanPointInPolygon
+
+
+export default turf

package/src/intersectMultiPolygon.mjs

@@ -0,0 +1,21 @@
+import isearr from 'wsemi/src/isearr.mjs'
+import turf from './getTurf.mjs'
+import toMultiPolygon from './toMultiPolygon.mjs'
+import distilMultiPolygon from './distilMultiPolygon.mjs'
+
+
+function intersectMultiPolygon(pgs, pgsInter) {
+
+    //check
+    if (!isearr(pgs)) {
+        return null
+    }
+
+    //pgNew
+    let r = turf.intersect(turf.helpers.multiPolygon(toMultiPolygon(pgs)), turf.helpers.multiPolygon(toMultiPolygon(pgsInter)))
+
+    return distilMultiPolygon(r)
+}
+
+
+export default intersectMultiPolygon

package/src/invCoordMultiPolygon.mjs

@@ -0,0 +1,22 @@
+import isearr from 'wsemi/src/isearr.mjs'
+import map from 'lodash/map'
+import invCoordPolygon from './invCoordPolygon.mjs'
+
+
+function invCoordMultiPolygon(pgs) {
+
+    //check
+    if (!isearr(pgs)) {
+        return null
+    }
+
+    //invCoordPolygon
+    let r = map(pgs, (pg) => {
+        return invCoordPolygon(pg)
+    })
+
+    return r
+}
+
+
+export default invCoordMultiPolygon

package/src/invCoordPolygon.mjs

@@ -0,0 +1,24 @@
+import isearr from 'wsemi/src/isearr.mjs'
+import map from 'lodash/map'
+
+
+function invCoordPolygon(pg) {
+    //因為turf的point是先經再緯跟leaflet相反, 故需相反座標
+
+    //check
+    if (!isearr(pg)) {
+        return null
+    }
+
+    //交換順序
+    let r = map(pg, (v) => {
+        return map(v, (vv) => {
+            return [vv[1], vv[0]] //一定需為長度2陣列之數據
+        })
+    })
+
+    return r
+}
+
+
+export default invCoordPolygon

package/src/isPointInPolygon.mjs

@@ -0,0 +1,21 @@
+import isearr from 'wsemi/src/isearr.mjs'
+import turf from './getTurf.mjs'
+import toMultiPolygon from './toMultiPolygon.mjs'
+
+
+function isPointInPolygon(p, pgs) {
+
+    //check
+    if (!isearr(p)) {
+        return null
+    }
+    if (!isearr(pgs)) {
+        return null
+    }
+
+    let r = turf.booleanPointInPolygon(p, turf.helpers.multiPolygon(toMultiPolygon(pgs)))
+    return r
+}
+
+
+export default isPointInPolygon

package/src/maskMultiPolygon.mjs

@@ -0,0 +1,21 @@
+import isearr from 'wsemi/src/isearr.mjs'
+import turf from './getTurf.mjs'
+import toMultiPolygon from './toMultiPolygon.mjs'
+import distilMultiPolygon from './distilMultiPolygon.mjs'
+
+
+function maskMultiPolygon(pgs) {
+
+    //check
+    if (!isearr(pgs)) {
+        return null
+    }
+
+    //pgNew
+    let r = turf.mask(turf.helpers.multiPolygon(toMultiPolygon(pgs)))
+
+    return distilMultiPolygon(r)
+}
+
+
+export default maskMultiPolygon

package/src/parseGeometryCollection.mjs

@@ -0,0 +1,27 @@
+import get from 'lodash/get'
+import each from 'lodash/each'
+
+
+function parseGeometryCollection(data) {
+
+    //gs
+    let gs = get(data, 'geometry.geometries', [])
+
+    //pgs
+    let pgs = []
+    each(gs, (v) => {
+        if (v.type === 'Polygon') {
+            pgs.push(v.coordinates)
+        }
+        else if (v.type === 'MultiPolygon') {
+            each(v.coordinates, (vv) => {
+                pgs.push(vv)
+            })
+        }
+    })
+
+    return pgs
+}
+
+
+export default parseGeometryCollection

package/src/simplifyMultiPolygon.mjs

@@ -0,0 +1,41 @@
+import get from 'lodash/get'
+import isearr from 'wsemi/src/isearr.mjs'
+import isbol from 'wsemi/src/isbol.mjs'
+import isnum from 'wsemi/src/isnum.mjs'
+import cdbl from 'wsemi/src/cdbl.mjs'
+import turf from './getTurf.mjs'
+import toMultiPolygon from './toMultiPolygon.mjs'
+
+
+function simplifyMultiPolygon(pgs, opt = {}) {
+
+    //check
+    if (!isearr(pgs)) {
+        return null
+    }
+
+    //tolerance
+    let tolerance = get(opt, 'tolerance')
+    if (!isnum(tolerance)) {
+        tolerance = 0.005
+    }
+    tolerance = cdbl(tolerance)
+
+    //highQuality
+    let highQuality = get(opt, 'highQuality')
+    if (!isbol(highQuality)) {
+        highQuality = true
+    }
+
+    //simplify
+    let r = turf.simplify(turf.multiPolygon(toMultiPolygon(pgs)), { tolerance, highQuality })
+
+    //get pgs
+    r = get(r, 'geometry.coordinates', [])
+    // console.log('r',r)
+
+    return r
+}
+
+
+export default simplifyMultiPolygon

package/src/splineMultiPolygon.mjs

@@ -0,0 +1,38 @@
+import map from 'lodash/map'
+import get from 'lodash/get'
+import cloneDeep from 'lodash/cloneDeep'
+import turf from './getTurf.mjs'
+
+
+function splineMultiPolygon(pgs, opt = {}) {
+    //splineMultiPolygon(pgs, { resolution: 50000, sharpness: 0.05 })
+
+    function core(pg, opt = {}) {
+
+        //cloneDeep
+        pg = cloneDeep(pg)
+
+        //pgNew
+        let pgNew = map(pg, (ps, k) => {
+            let line = turf.helpers.lineString(ps)
+            let r = turf.bezierSpline(line, opt)
+            let psNew = get(r, 'geometry.coordinates')
+            return psNew
+        })
+
+        return pgNew
+    }
+
+    //cloneDeep
+    pgs = cloneDeep(pgs)
+
+    //core
+    pgs = map(pgs, (pg) => {
+        return core(pg, opt)
+    })
+
+    return pgs
+}
+
+
+export default splineMultiPolygon