@sword916/vae-map-plus 1.0.0 → 1.0.1

package/src/plugins/L.FootageCalculator.Area/index.js

@@ -1,263 +0,0 @@
-import './../L.GeoUtil'
-
-L.FootageCalculator = L.FootageCalculator || {}
-
-// 工作面推进计算器
-L.FootageCalculator.Area = L.Evented.extend({
-
-    options: {
-        crs: L.CRS.EPSG3857, // 坐标转换类
-        latlngs: [], // 边界经纬度
-        headStart: null, // 机头经纬度
-        headEnd: null, // 机头终点经纬度
-        tailStart: null, // 机尾经纬度
-        tailEnd: null, /// 机尾终点经纬度
-    },
-
-    initialize(opts) {
-        L.setOptions(this, opts)
-
-        // 校验参数
-        const { crs, latlngs, headStart, headEnd, tailStart, tailEnd } = this.options
-        if (crs && crs.project && crs.unproject) {
-            this.crs = crs
-        } else {
-            throw new Error('请传入正确的crs参数')
-        }
-        if (Array.isArray(latlngs) && latlngs.length > 2) {
-            this.latlngs = latlngs
-        } else {
-            throw new Error('请传入正确的latlngs参数')
-        }
-        // 校验机头机尾参数
-        function assetVertex(value, property) {
-            if (value < 0) {
-                throw new Error(`请传入正确的${property}参数，此参数必须是latlngs的某个节点`)
-            }
-        }
-        this.hsIndex = _.findIndex(latlngs, o => _.isEqual(o, headStart))
-        assetVertex(this.hsIndex, 'headStart')
-        this.heIndex = _.findIndex(latlngs, o => _.isEqual(o, headEnd))
-        assetVertex(this.heIndex, 'headEnd')
-        this.tsIndex = _.findIndex(latlngs, o => _.isEqual(o, tailStart))
-        assetVertex(this.tsIndex, 'tailStart')
-        this.teIndex = _.findIndex(latlngs, o => _.isEqual(o, tailEnd))
-        assetVertex(this.teIndex, 'tailEnd')
-        // 查重
-        if (_.uniq([this.hsIndex, this.heIndex, this.tsIndex, this.teIndex]).length < 4) {
-            throw new Error('机头机尾坐标不允许重复')
-        }
-        // 起点
-        const differIndex = Math.abs(this.hsIndex - this.tsIndex)
-        if (differIndex != 1 && differIndex != latlngs.length - 1) {
-            throw new Error('机头和机尾起点必须相邻')
-        }
-
-        this.initParams()
-    },
-
-    // 初始化参数
-    initParams() {
-        // 经纬度转坐标
-        this.points = this.latlngs.map(latlng => {
-            return this.crs.project(toLatLng(latlng))
-        })
-
-        // 计算预设路径
-        // 条件：机头机尾起点相邻，推进方向相反
-        // 1. 主方向：hs0 ts1视为正向，hs1 ts0视为反向
-        // 2. 主方向为正：机头推进方向为反，否则路径交叉
-        // 3. 主方向为反：同2，机头推进方向为正，机尾推进方向为反
-        const length = this.latlngs.length
-        let headPoints = []
-        let tailPoints = []
-        let dirPositive = this.hsIndex < this.tsIndex
-        if (Math.abs(this.hsIndex - this.tsIndex) == length - 1) {
-            dirPositive = this.tsIndex == 0
-        }
-        if (dirPositive) {
-            // 机头路径
-            // hs小于he时，机头路径过起点，提升后再循环
-            let tempHsIndex = this.hsIndex
-            if (this.heIndex > this.hsIndex) {
-                tempHsIndex += length
-            }
-            for (let i = this.heIndex; i <= tempHsIndex; i++) {
-                headPoints.push(this.points[i >= length ? i - length : i])
-            }
-            headPoints.reverse()
-            // 机尾路径
-            let tempTeIndex = this.teIndex
-            if (this.tsIndex > this.teIndex) {
-                tempTeIndex += length
-            }
-            for (let i = this.tsIndex; i <= tempTeIndex; i++) {
-                tailPoints.push(this.points[i >= length ? i - length : i])
-            }
-        } else {
-            // 机头路径
-            let tempHeIndex = this.heIndex
-            if (this.hsIndex > this.heIndex) {
-                tempHeIndex += length
-            }
-            for (let i = this.hsIndex; i <= tempHeIndex; i++) {
-                headPoints.push(this.points[i >= length ? i - length : i])
-            }
-            // 机尾路径
-            let tempTsIndex = this.tsIndex
-            if (this.teIndex > this.tsIndex) {
-                tempTsIndex += length
-            }
-            for (let i = this.teIndex; i <= tempTsIndex; i++) {
-                tailPoints.push(this.points[i >= length ? i - length : i])
-            }
-            tailPoints.reverse()
-        }
-
-        // 处理线段
-        this.headSegments = []
-        headPoints.forEach((point, i) => {
-            if (i > 0) {
-                this.headSegments.push({ start: headPoints[i - 1], end: point })
-            }
-        })
-        this.tailSegments = []
-        tailPoints.forEach((point, i) => {
-            if (i > 0) {
-                this.tailSegments.push({ start: tailPoints[i - 1], end: point })
-            }
-        })
-    },
-
-    /**
-     * 执行计算
-     * @param {L.LatLng} headStart 机头起点
-     * @param {L.LatLng} tailStart 机尾起点
-     * @param {Number} headDistance 机头推进距离
-     * @param {Number} tailDistance 机尾推进距离
-     * @returns {L.LatLng} headEnd 推进后机头的经纬度
-     * @returns {L.LatLng} tailEnd 推进后机尾的经纬度
-     * @returns {Array<L.LatLng>} latlngs 推进的区域范围 
-     */
-    doCalculate({ headStart, tailStart, headDistance, tailDistance }) {
-        const headStartPoint = this.crs.project(toLatLng(headStart))
-        const tailStartPoint = this.crs.project(toLatLng(tailStart))
-        const headResult = this.calcWorkPath(headStartPoint, this.headSegments, headDistance)
-        const tailResult = this.calcWorkPath(tailStartPoint, this.tailSegments, tailDistance)
-
-        // 拼装计算结果
-        const headEnd = this.crs.unproject(_.last(headResult.path))
-        const tailEnd = this.crs.unproject(_.last(tailResult.path))
-        let latlngs = []
-        let headPath = headResult.path
-        let tailPath = tailResult.path
-        tailPath.reverse()
-        // 推进范围
-        new Array(headPath, tailPath).forEach(path => {
-            path.forEach(v => {
-                latlngs.push(this.crs.unproject(v))
-            })
-        })
-
-        return { headEnd, tailEnd, latlngs }
-    },
-
-    /**
-     * 计算一次推进的结果
-     * @param {L.Point} start 起点
-     * @param {Array} segments 线段
-     * @param {Number} distance 推进距离
-     */
-    calcWorkPath(start, segments, distance) {
-        let sumDistance = 0 // 累计计算的距离
-        let startIndex = -1 // 起点所在线段的序号
-        let endIndex = -1 // 终点所在线段的序号
-        let end // 终点坐标
-
-        segments.forEach((segment, i) => {
-            // 终点确认后终止计算
-            if (endIndex < 0) {
-                // 当前段上的起点
-                let curStart = segment.start
-                // 确定起点序号，若起点距离线段小于0.01，视为在该段上
-                if (startIndex < 0 && L.LineUtil.pointToSegmentDistance(start, segment.start, segment.end) < 0.01) {
-                    startIndex = i
-                    curStart = start
-                }
-                // 当前段提供的距离
-                let curDistance = 0
-                if (startIndex >= 0) {
-                    curDistance = curStart.distanceTo(segment.end)
-                }
-                // 确定终点序号，若累计距离超过推进距离，即可在当前段上确认终点
-                if (sumDistance + curDistance >= distance) {
-                    endIndex = i
-                    end = this.calcEndPointOnLine(curStart, segment.end, distance - sumDistance)
-                }
-                sumDistance += curDistance
-            }
-        })
-
-        // 距离过长无法确认终点时，使用末点作为临时终点
-        let tempEndIndex = endIndex
-        if (endIndex < 0) {
-            tempEndIndex = segments.length - 1
-            end = _.last(segments).end
-        }
-
-        // 拼装推进路径
-        let path = [start]
-        for (let i = startIndex; i < tempEndIndex; i++) {
-            path.push(segments[i].end)
-        }
-        path.push(end)
-
-        // 挤压点偏移
-        if (path.length == 2 && path[0].x == path[1].x && path[0].y == path[1].y) {
-            const lastSegment = _.last(segments)
-            const rad = L.GeoUtil.computeRad(lastSegment.start, lastSegment.end)
-            path[0] = path[1].subtract(L.point(0.01 * Math.cos(rad), 0.01 * Math.sin(rad)))
-        }
-
-        // 拼装剩余路径
-        let remainingPath = []
-        if (tempEndIndex == endIndex) {
-            remainingPath = [end]
-            for (let i = tempEndIndex; i < segments.length - 1; i++) {
-                remainingPath.push(segments[i].end)
-            }
-            remainingPath.push(_.last(segments).end)
-        }
-
-        // 尾段方向弧度
-        let endSegment = segments[endIndex]
-        if (endIndex < 0) {
-            endSegment = _.last(segments)
-        }
-        let endRad = L.GeoUtil.computeRad(endSegment.start, endSegment.end)
-
-        return { path, remainingPath, endRad }
-    },
-
-    // 获取a点向b点方向延伸distance后的坐标
-    calcEndPointOnLine(a, b, distance) {
-        const rad = L.GeoUtil.computeRad(a, b)
-        const dx = distance * Math.cos(rad)
-        const dy = distance * Math.sin(rad)
-
-        return a.add(L.point(dx, dy))
-    }
-
-})
-
-function toLatLng(value) {
-    if (!(value instanceof L.LatLng)) {
-        value = L.latLng(value)
-    }
-    return value
-}
-
-L.footageCalculator = L.footageCalculator || {}
-L.footageCalculator.area = function(options) {
-    return new L.FootageCalculator.Area(options)
-}

package/src/plugins/L.FootageCalculator.Line/index.js

@@ -1,273 +0,0 @@
-import './../L.GeoUtil'
-
-L.FootageCalculator = L.FootageCalculator || {}
-
-// 巷道进尺计算器
-L.FootageCalculator.Line = L.Evented.extend({
-
-    options: {
-        crs: L.CRS.EPSG3857, // 坐标转换类
-        latlngs: [], // 中心线
-        width: 0, // 巷道宽度
-    },
-
-    initialize(opts) {
-        L.setOptions(this, opts)
-
-        // 校验参数
-        const crs = this.options.crs
-        if (crs && crs.project && crs.unproject) {
-            this.crs = crs
-        } else {
-            throw new Error('请传入正确的crs参数')
-        }
-        const latlngs = this.options.latlngs
-        const width = this.options.width
-        if (Array.isArray(latlngs) && latlngs.length > 1 && width > 0) {
-            this.latlngs = latlngs
-            this.width = width
-        } else {
-            throw new Error('请传入正确的latlngs和width参数')
-        }
-
-        this.initParams()
-    },
-
-    // 初始化参数
-    initParams() {
-        // 格式化点
-        this.points = this.latlngs.map(latlng => {
-            if (!(latlng instanceof L.LatLng)) {
-                latlng = L.latLng(latlng)
-            }
-            return this.crs.project(latlng)
-        })
-        // 格式化线段
-        this.segments = []
-        this.points.forEach((point, i) => {
-            if (i > 0) {
-                let offsetDistance = 0
-                if (i > 1) {
-                    offsetDistance = this.calcOffsetDistance(
-                        this.points[i - 2],
-                        this.points[i - 1],
-                        this.points[i],
-                        this.width / 2
-                    )
-                }
-                this.segments.push({
-                    start: this.points[i - 1],
-                    end: point,
-                    offsetDistance
-                })
-            }
-        })
-    },
-
-    /**
-     * 执行计算
-     * @param {L.LatLng} start 起点
-     * @param {Number} distance 推进距离，米
-     */
-    doCalculate({ start, distance }) {
-        if (distance > 0) {
-            if (!(start instanceof L.LatLng)) {
-                start = L.latLng(start)
-            }
-            const startPoint = this.crs.project(start)
-            const { path, remainingPath, endRad } = this.calcWorkPath(startPoint, this.segments, distance)
-            const area = this.calcWorkArea({ path, width: this.width / 2 })
-
-            const latlngPath = path.map(v => {
-                return this.crs.unproject(v)
-            })
-            const latlngArea = area.map(v => {
-                return this.crs.unproject(v)
-            })
-            const latlngRemainingPath = remainingPath.map(v => {
-                return this.crs.unproject(v)
-            })
-            const endAngle = L.GeoUtil.toClockwiseAngle(L.GeoUtil.radToAngle(endRad))
-
-            return { path: latlngPath, remainingPath: latlngRemainingPath, area: latlngArea, endAngle }
-
-        } else {
-            throw new Error('distance参数必须大于0')
-        }
-    },
-
-    /**
-     * 计算一次推进的结果
-     * @param {L.Point} start 起点
-     * @param {Array} segments 线段
-     * @param {Number} distance 推进距离
-     */
-    calcWorkPath(start, segments, distance) {
-        let sumDistance = 0 // 累计计算的距离
-        let startIndex = -1 // 起点所在线段的序号
-        let endIndex = -1 // 终点所在线段的序号
-        let end // 终点坐标
-
-        segments.forEach((segment, i) => {
-            // 终点确认后终止计算
-            if (endIndex < 0) {
-                // 斜角补足
-                distance += segment.offsetDistance
-                // 当前段上的起点
-                let curStart = segment.start
-                // 确定起点序号，若起点距离线段小于0.01，视为在该段上
-                if (startIndex < 0 && L.LineUtil.pointToSegmentDistance(start, segment.start, segment.end) < 0.01) {
-                    startIndex = i
-                    curStart = start
-                }
-                // 当前段提供的距离
-                let curDistance = 0
-                if (startIndex >= 0) {
-                    curDistance = curStart.distanceTo(segment.end)
-                }
-                // 确定终点序号，若累计距离超过推进距离，即可在当前段上确认终点
-                if (sumDistance + curDistance >= distance) {
-                    endIndex = i
-                    end = this.calcEndPointOnLine(curStart, segment.end, distance - sumDistance)
-                }
-                sumDistance += curDistance
-            }
-        })
-
-        // 距离过长无法确认终点时，使用末点作为临时终点
-        let tempEndIndex = endIndex
-        if (endIndex < 0) {
-            tempEndIndex = segments.length - 1
-            end = _.last(segments).end
-        }
-
-        // 拼装推进路径
-        let path = [start]
-        for (let i = startIndex; i < tempEndIndex; i++) {
-            path.push(segments[i].end)
-        }
-        path.push(end)
-
-        // 挤压点偏移
-        if (path.length == 2 && path[0].x == path[1].x && path[0].y == path[1].y) {
-            const lastSegment = _.last(segments)
-            const rad = L.GeoUtil.computeRad(lastSegment.start, lastSegment.end)
-            path[0] = path[1].subtract(L.point(0.01 * Math.cos(rad), 0.01 * Math.sin(rad)))
-        }
-
-        // 拼装剩余路径
-        let remainingPath = []
-        if (tempEndIndex == endIndex) {
-            remainingPath = [end]
-            for (let i = tempEndIndex; i < segments.length - 1; i++) {
-                remainingPath.push(segments[i].end)
-            }
-            remainingPath.push(_.last(segments).end)
-        }
-
-        // 尾段方向弧度
-        let endSegment = segments[endIndex]
-        if (endIndex < 0) {
-            endSegment = _.last(segments)
-        }
-        let endRad = L.GeoUtil.computeRad(endSegment.start, endSegment.end)
-
-        return { path, remainingPath, endRad }
-    },
-
-    /**
-     * 根据中心线路径和法线长度，计算推进范围
-     * @param {Array<L.Point>} path 推进路径
-     * @param {Number} width 法线长度
-     */
-    calcWorkArea({ path, width }) {
-        let forwardPath = []
-        let backwardPath = []
-        let array = path.map((v, i) => {
-            // 起点
-            if (i == 0) {
-                const rad = L.GeoUtil.computeRad(path[i], path[i + 1])
-                return this.calcVerticalOffestPoints(v, rad, width)
-            }
-            // 终点
-            else if (i == path.length - 1) {
-                const rad = L.GeoUtil.computeRad(path[i - 1], path[i])
-                return this.calcVerticalOffestPoints(v, rad, width)
-            }
-            // 中段
-            else {
-                // 上一段角度
-                const preRad = L.GeoUtil.computeRad(path[i - 1], path[i])
-                // 当前段角度
-                const curRad = L.GeoUtil.computeRad(path[i], path[i + 1])
-                // 八个偏移点
-                const ps1 = this.calcVerticalOffestPoints(path[i - 1], preRad, width)
-                const ps2 = this.calcVerticalOffestPoints(path[i], preRad, width)
-                const ps3 = this.calcVerticalOffestPoints(path[i], curRad, width)
-                const ps4 = this.calcVerticalOffestPoints(path[i + 1], curRad, width)
-                // 交点
-                const intersection1 = L.GeoUtil.linesIntersection(ps1[0], ps2[0], ps3[0], ps4[0])
-                const intersection2 = L.GeoUtil.linesIntersection(ps1[1], ps2[1], ps3[1], ps4[1])
-
-                if (intersection1 && intersection2) {
-                    return [intersection1, intersection2]
-                }
-            }
-        })
-        array.forEach(v => {
-            if (v) {
-                forwardPath.push(v[0])
-                backwardPath.push(v[1])
-            }
-        })
-
-        return _.concat(forwardPath, _.reverse(backwardPath))
-    },
-
-    // 获取a点向b点方向延伸distance后的坐标
-    calcEndPointOnLine(a, b, distance) {
-        const rad = L.GeoUtil.computeRad(a, b)
-        const dx = distance * Math.cos(rad)
-        const dy = distance * Math.sin(rad)
-
-        return a.add(L.point(dx, dy))
-    },
-
-    // 计算补足距离
-    calcOffsetDistance(p1, p2, p3, width) {
-        const segRad = L.GeoUtil.segmentsRad(p2, p1, p3, width)
-        const preLineRad = L.GeoUtil.computeRad(p1, p2)
-        const curLineRad = L.GeoUtil.computeRad(p2, p3)
-        const ps1 = this.calcVerticalOffestPoints(p1, preLineRad, width)
-        const ps2 = this.calcVerticalOffestPoints(p2, preLineRad, width)
-        const ps3 = this.calcVerticalOffestPoints(p2, curLineRad, width)
-        const ps4 = this.calcVerticalOffestPoints(p3, curLineRad, width)
-
-        let intersection = null
-        if (segRad > 0) {
-            intersection = L.GeoUtil.linesIntersection(ps1[1], ps2[1], ps3[1], ps4[1])
-        } else {
-            intersection = L.GeoUtil.linesIntersection(ps1[0], ps2[0], ps3[0], ps4[0])
-        }
-        if (intersection) {
-            const foot = L.GeoUtil.footPointOnLine(intersection, p2, p3)
-            return foot.distanceTo(p2)
-        } else {
-            return 0
-        }
-    },
-
-    // 获取目标点的在给定方向的法线上的两个偏移点
-    calcVerticalOffestPoints(point, rad, distance) {
-        const vertRad = rad - Math.PI / 2
-        const offset = L.point(distance * Math.cos(vertRad), distance * Math.sin(vertRad))
-
-        return [point.add(offset), point.subtract(offset)]
-    }
-
-})
-
-L.footageCalculator = L.footageCalculator || {}
-L.footageCalculator.line = function (options) {
-    return new L.FootageCalculator(options)
-}

package/src/plugins/L.GeoUtil/buffer.js

@@ -1,67 +0,0 @@
-import * as turf from '@turf/helpers'
-import buffer from '@turf/buffer'
-
-// 转换为L.LatLng数组
-const geoJSONTolatLngs = json => {
-    let result = []
-    const coordinates = json.geometry.coordinates
-    coordinates.forEach(coords => {
-        result.push(coords.map(e => {
-            return {
-                lat: e[1],
-                lng: e[0]
-            }
-        }))
-    })
-    return result
-}
-
-export default {
-
-
-    /**
-     * 点缓冲分析
-     * @param {L.LatLng} center 中心点
-     * @param {Number} distance 缓冲距离
-     * @param {String} units 单位
-     * @returns {Array<Array<L.LatLng>>} 缓冲区经纬度序列
-     */
-    bufferPoint(center, distance, units = 'meters') {
-        const turfLatLng = [center.lng, center.lat]
-        const geoJSONData = buffer(turf.point(turfLatLng), distance, { units })
-        return geoJSONTolatLngs(geoJSONData)
-    },
-
-    /**
-     * 路径缓冲分析
-     * @param {Array<L.LatLng>} latLngs 路径经纬度序列
-     * @param {Number} distance 缓冲距离
-     * @param {String} units 单位
-     * @returns {Array<Array<L.LatLng>>} 缓冲区经纬度序列
-     */
-    bufferLine(latLngs, distance, units = 'meters') {
-        const turfLatLngs = latLngs.map(e => {
-            return [e.lng, e.lat]
-        })
-        const geoJSONData = buffer(turf.lineString(turfLatLngs), distance, { units })
-        return geoJSONTolatLngs(geoJSONData)
-    },
-
-    /**
-     * 区域缓冲分析
-     * @param {Array<L.LatLng>} latLngs 区域经纬度序列
-     * @param {Number} distance 缓冲距离
-     * @param {String} units 单位
-     * @returns {Array<Array<L.LatLng>>} 缓冲区经纬度序列
-     */
-    bufferArea(latLngs, distance, units = 'meters') {
-        let turfLatLngs = latLngs.map(e => {
-            return [e.lng, e.lat]
-        })
-        turfLatLngs.push(turfLatLngs[0])
-        const geoJSONData = buffer(turf.polygon([turfLatLngs]), distance, { units })
-        return geoJSONTolatLngs(geoJSONData)
-    }
-
-
-}