gis-common 2.1.1 → 2.2.2

package/src/utils/GeoUtils.js

@@ -0,0 +1,242 @@
+import MathUtils from './MathUtils'
+export default {
+    toRadian: Math.PI / 180,
+    R: 6371393,
+    /**
+     * 验证经纬度坐标
+     *
+     * @param {*} lng
+     * @param {*} lat
+     * @returns {*}  {boolean}
+     */
+    isLnglat(lng, lat) {
+        return !!(+lat > -90 && +lat < 90 && +lng > -180 && +lng < 180)
+    },
+    /**
+     * 格式化经纬度(转度分秒)
+     *
+     * @param {*} lng
+     * @param {*} lat
+     * @returns {*}
+     */
+    formatLnglat(lng, lat) {
+        let res = ''
+        function format(value) {
+            const a = parseFloat(value)
+            const degree = parseInt(a)
+            let min = parseInt((a - degree) * 60)
+            let sec = (a - degree) * 3600 - min * 60
+            return degree + '°' + min + '′' + sec.toFixed(2) + '″'
+        }
+        if (lng && lat) {
+            res = format(lng) + ',' + format(lat)
+        }
+        return res
+    },
+    /**
+     * 度分秒转十进制
+     *
+     * @param {*} lng
+     * @param {*} lat
+     * @returns {*}
+     */
+    transformLnglat(lng, lat) {
+        function dms2deg(s) {
+            var sw = /[sw]/i.test(s)
+            var f = sw ? -1 : 1
+            var bits = s.match(/[\d.]+/g)
+            var result = 0
+            for (var i = 0, iLen = bits.length; i < iLen; i++) {
+                result += bits[i] / f
+                f *= 60
+            }
+            return result
+        }
+        if (lng && lat) {
+            return {
+                lng: dms2deg(lng),
+                lat: dms2deg(lat),
+            }
+        }
+    },
+    /**
+     * 判断点是否在多边形内
+     *
+     * @param {*} p
+     * @param {*} poly
+     * @returns {*}
+     */
+    rayCasting(p, poly) {
+        var px = p.x,
+            py = p.y,
+            flag = false
+        for (var i = 0, l = poly.length, j = l - 1; i < l; j = i, i++) {
+            var sx = poly[i].x,
+                sy = poly[i].y,
+                tx = poly[j].x,
+                ty = poly[j].y
+            // 点与多边形顶点重合
+            if ((sx === px && sy === py) || (tx === px && ty === py)) {
+                return 'on'
+            }
+            // 判断线段两端点是否在射线两侧
+            if ((sy < py && ty >= py) || (sy >= py && ty < py)) {
+                // 线段上与射线 Y 坐标相同的点的 X 坐标
+                var x = sx + ((py - sy) * (tx - sx)) / (ty - sy)
+                // 点在多边形的边上
+                if (x === px) {
+                    return 'on'
+                }
+                // 射线穿过多边形的边界
+                if (x > px) {
+                    flag = !flag
+                }
+            }
+        }
+        // 射线穿过多边形边界的次数为奇数时点在多边形内
+        return flag ? 'in' : 'out'
+    },
+    /**
+     * 计算两点距离
+     *
+     * @param {*} fromPoint
+     * @param {*} toPoint
+     * @returns {*}
+     */
+    wgs84PointsDistance(fromPoint, toPoint) {
+        var PI = Math.PI
+        function getRad(d) {
+            return (d * PI) / 180.0
+        }
+        if (arguments.length != 2) {
+            return 0
+        }
+        lon1 = fromPoint.x
+        lat1 = fromPoint.y
+        lon2 = toPoint.x
+        lat2 = toPoint.y
+        var a = 6378137,
+            b = 6356752.3142,
+            f = 1 / 298.257223563
+        var L = getRad(lon2 - lon1)
+        var U1 = Math.atan((1 - f) * Math.tan(getRad(lat1)))
+        var U2 = Math.atan((1 - f) * Math.tan(getRad(lat2)))
+        var sinU1 = Math.sin(U1),
+            cosU1 = Math.cos(U1)
+        var sinU2 = Math.sin(U2),
+            cosU2 = Math.cos(U2)
+        var lambda = L,
+            lambdaP,
+            iterLimit = 100
+        do {
+            var sinLambda = Math.sin(lambda),
+                cosLambda = Math.cos(lambda)
+            var sinSigma = Math.sqrt(
+                cosU2 * sinLambda * (cosU2 * sinLambda) + (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda) * (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda)
+            )
+            if (sinSigma == 0) return 0
+            var cosSigma = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda
+            var sigma = Math.atan2(sinSigma, cosSigma)
+            var sinAlpha = (cosU1 * cosU2 * sinLambda) / sinSigma
+            var cosSqAlpha = 1 - sinAlpha * sinAlpha
+            var cos2SigmaM = cosSigma - (2 * sinU1 * sinU2) / cosSqAlpha
+            if (isNaN(cos2SigmaM)) cos2SigmaM = 0
+            var C = (f / 16) * cosSqAlpha * (4 + f * (4 - 3 * cosSqAlpha))
+            lambdaP = lambda
+            lambda = L + (1 - C) * f * sinAlpha * (sigma + C * sinSigma * (cos2SigmaM + C * cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM)))
+        } while (Math.abs(lambda - lambdaP) > 1e-12 && --iterLimit > 0)
+        if (iterLimit == 0) {
+            return NaN
+        }
+        var uSq = (cosSqAlpha * (a * a - b * b)) / (b * b)
+        var A = 1 + (uSq / 16384) * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)))
+        var B = (uSq / 1024) * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)))
+        var deltaSigma =
+            B *
+            sinSigma *
+            (cos2SigmaM +
+                (B / 4) *
+                    (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM) -
+                        (B / 6) * cos2SigmaM * (-3 + 4 * sinSigma * sinSigma) * (-3 + 4 * cos2SigmaM * cos2SigmaM)))
+        var s = b * A * (sigma - deltaSigma)
+        var fwdAz = Math.atan2(cosU2 * sinLambda, cosU1 * sinU2 - sinU1 * cosU2 * cosLambda)
+        var revAz = Math.atan2(cosU1 * sinLambda, -sinU1 * cosU2 + cosU1 * sinU2 * cosLambda)
+        return s
+    },
+    /**
+     * P1绕一个坐标点P2旋转θ角度后,新的坐标的计算公式
+     *
+     * @param {*} p1
+     * @param {*} p2
+     * @param {*} θ 旋转角度，正：表示顺时针，负：表示逆时针
+     */
+    rotatePoint(p1, p2, θ) {
+        const x = (p1.x - p2.x) * Math.cos((Math.PI / 180) * -θ) - (p1.y - p2.y) * Math.sin((Math.PI / 180) * -θ) + p2.x
+        const y = (p1.x - p2.x) * Math.sin((Math.PI / 180) * -θ) + (p1.y - p2.y) * Math.cos((Math.PI / 180) * -θ) + p2.y
+        return { x, y }
+    },
+    /**
+     * 计算latlng2相对于latlng1的方位角和距离
+     *
+     * @param {*} latlng1
+     * @param {*} latlng2
+     * @returns {*}  {boolean}
+     */
+    calcBearAndDisByPoints(latlng1, latlng2) {
+        var f1 = parseFloat(latlng1.lat),
+            l1 = parseFloat(latlng1.lng),
+            f2 = parseFloat(latlng2.lat),
+            l2 = parseFloat(latlng2.lng)
+        var y = Math.sin((l2 - l1) * this.toRadian) * Math.cos(f2 * this.toRadian)
+        var x =
+            Math.cos(f1 * this.toRadian) * Math.sin(f2 * this.toRadian) -
+            Math.sin(f1 * this.toRadian) * Math.cos(f2 * this.toRadian) * Math.cos((l2 - l1) * this.toRadian)
+        var angle = Math.atan2(y, x) * (180 / Math.PI)
+        var deltaF = (f2 - f1) * this.toRadian
+        var deltaL = (l2 - l1) * this.toRadian
+        var a =
+            Math.sin(deltaF / 2) * Math.sin(deltaF / 2) +
+            Math.cos(f1 * this.toRadian) * Math.cos(f2 * this.toRadian) * Math.sin(deltaL / 2) * Math.sin(deltaL / 2)
+        var c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
+        var distance = this.R * c
+        return {
+            angle,
+            distance,
+        }
+    },
+    /**
+     * 根据方位角和距离生成新的坐标
+     *
+     * @param {*} latlng
+     * @param {*} angle
+     * @param {*} distance
+     * @returns {*}
+     */
+    calcPointByBearAndDis(latlng, angle, distance) {
+        const sLat = MathUtils.toRadians(parseFloat(latlng.lat))
+        const sLng = MathUtils.toRadians(parseFloat(latlng.lng))
+        angle = parseFloat(angle)
+        distance = parseFloat(distance)
+        const d = distance / this.R
+        angle = MathUtils.toRadians(angle)
+        const lat = Math.asin(Math.sin(sLat) * Math.cos(d) + Math.cos(sLat) * Math.sin(d) * Math.cos(angle))
+        const lon = sLng + Math.atan2(Math.sin(angle) * Math.sin(d) * Math.cos(sLat), Math.cos(d) - Math.sin(sLat) * Math.sin(lat))
+        return {
+            lat: MathUtils.toDegrees(lat),
+            lng: MathUtils.toDegrees(lon),
+        }
+    },
+    mercatorTolonlat(x, y) {
+        const lng = (x / 20037508.34) * 180
+        var mmy = (y / 20037508.34) * 180
+        const lat = (180 / Math.PI) * (2 * Math.atan(Math.exp((mmy * Math.PI) / 180)) - Math.PI / 2)
+        return { lng, lat }
+    },
+    lonlatToMercator(lng, lat) {
+        var earthRad = 6378137.0
+        const x = ((lng * Math.PI) / 180) * earthRad
+        var a = (lat * Math.PI) / 180
+        const y = (earthRad / 2) * Math.log((1.0 + Math.sin(a)) / (1.0 - Math.sin(a)))
+        return { x, y }
+    },
+}

package/src/utils/MathUtils.js

@@ -0,0 +1,49 @@
+export default {
+    DEG2RAD: Math.PI / 180,
+    RAD2DEG: 180 / Math.PI,
+    randInt(low, high) {
+        return low + Math.floor(Math.random() * (high - low + 1))
+    },
+    randFloat(low, high) {
+        return low + Math.random() * (high - low)
+    },
+    /**
+     * 角度转弧度
+     *
+     * @param {*} degrees
+     * @returns {*}
+     */
+    degreesToRadians(degrees) {
+        return degrees * this.DEG2RAD
+    },
+    /**
+     * 角度转弧度
+     *
+     * @param {*} degrees
+     * @returns {*}
+     */
+    toRadians(degrees) {
+        return degrees * this.DEG2RAD
+    },
+    /**
+     * 弧度转角度
+     *
+     * @param {*} radians
+     * @returns {*}
+     */
+    radiansToDegrees(radians) {
+        return radians * this.RAD2DEG
+    },
+    /**
+     * 弧度转角度
+     *
+     * @param {*} radians
+     * @returns {*}
+     */
+    toDegrees(radians) {
+        return radians * this.RAD2DEG
+    },
+    formatFloat(value, n = 2) {
+        return Math.round(value * Math.pow(10, n)) / Math.pow(10, n)
+    },
+}

package/src/utils/OptimizeUtils.js

@@ -0,0 +1,94 @@
+export default {
+    /**
+     * @desc  在事件被触发n秒后再执行回调函数，如果在这n秒内又被触发，则重新计时
+     * @desc  防止onresize，scroll，mousemove ,mousehover等，会被频繁触发影响性能
+     * @param  func 需要执行的函数
+     * @param  wait 延迟执行时间（毫秒）
+     * @param  immediate---true 表立即执行，false 表非立即执行
+     * eg: window.addEventListener("resize",debounce(handle,1000));
+     * @returns {*}
+     */
+    debounce(func, wait, immediate = true) {
+        let timeout, args, context, timestamp, result
+
+        const later = function () {
+            // 据上一次触发时间间隔
+            const last = +new Date() - timestamp
+
+            // 上次被包装函数被调用时间间隔last小于设定时间间隔wait
+            if (last < wait && last > 0) {
+                timeout = setTimeout(later, wait - last)
+            } else {
+                timeout = null
+                // 如果设定为immediate===true，因为开始边界已经调用过了此处无需调用
+                if (!immediate) {
+                    result = func.apply(context, args)
+                    if (!timeout) context = args = null
+                }
+            }
+        }
+
+        return function (...args) {
+            context = this
+            timestamp = +new Date()
+            const callNow = immediate && !timeout
+            // 如果延时不存在，重新设定延时
+            if (!timeout) timeout = setTimeout(later, wait)
+            if (callNow) {
+                result = func.apply(context, args)
+                context = args = null
+            }
+
+            return result
+        }
+    },
+    /**
+     * 规定一个单位时间，在这个单位时间内，只能有一次触发事件的回调函数执行，如果在同一个单位时间内某事件被触发多次，只有一次能生效
+     *
+     * @param {*} func
+     * @param {*} wait
+     * @param {*} type 1 表时间戳版，2 表定时器版
+     * @returns {*}
+     */
+    throttle(func, wait, type) {
+        if (type === 1) {
+            var previous = 0
+        } else if (type === 2) {
+            var timeout
+        }
+        return function () {
+            let context = this
+            let args = arguments
+            if (type === 1) {
+                let now = Date.now()
+                if (now - previous > wait) {
+                    func.apply(context, args)
+                    previous = now
+                }
+            } else if (type === 2) {
+                if (!timeout) {
+                    timeout = setTimeout(() => {
+                        timeout = null
+                        func.apply(context, args)
+                    }, wait)
+                }
+            }
+        }
+    },
+    /**
+     * 延时递归
+     *
+     * @param {Number} frequency 间隔时间ms
+     * @param {Number} duration 持续时间ms
+     */
+    recurve(fun, frequency = 500, duration = 5000) {
+        let timer = 0
+        setTimeout(function fn() {
+            timer++
+            if (timer < Math.floor(duration / frequency)) {
+                fun.call(this)
+                setTimeout(fn, frequency)
+            }
+        })
+    },
+}

package/src/utils/StringUtils.js

@@ -0,0 +1,135 @@
+import CommUtils from './CommUtils'
+export default {
+    /**
+     * 常用正则验证
+     *
+     * @param {*} str
+     * @param {*} type
+     * @returns {*}
+     */
+    checkStr(str, type) {
+        switch (type) {
+            case 'phone': // 手机号码
+                return /^1[3|4|5|6|7|8|9][0-9]{9}$/.test(str)
+            case 'tel': // 座机
+                return /^(0\d{2,3}-\d{7,8})(-\d{1,4})?$/.test(str)
+            case 'card': // 身份证
+                return /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/.test(str)
+            case 'pwd': // 密码以字母开头，长度在6~18之间，只能包含字母、数字和下划线
+                return /^[a-zA-Z]\w{5,17}$/.test(str)
+            case 'postal': // 邮政编码
+                return /[1-9]\d{5}(?!\d)/.test(str)
+            case 'QQ': // QQ号
+                return /^[1-9][0-9]{4,9}$/.test(str)
+            case 'email': // 邮箱
+                return /^[\w-]+(\.[\w-]+)*@[\w-]+(\.[\w-]+)+$/.test(str)
+            case 'money': // 金额(小数点2位)
+                return /^\d*(?:\.\d{0,2})?$/.test(str)
+            case 'URL': // 网址
+                return /(http|ftp|https):\/\/[\w\-_]+(\.[\w\-_]+)+([\w\-\.,@?^=%&:/~\+#]*[\w\-\@?^=%&/~\+#])?/.test(str)
+            case 'IP': // IP
+                return /((?:(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d?\\d))/.test(str)
+            case 'date': // 日期时间
+                return /^(\d{4})\-(\d{2})\-(\d{2}) (\d{2})(?:\:\d{2}|:(\d{2}):(\d{2}))$/.test(str) || /^(\d{4})\-(\d{2})\-(\d{2})$/.test(str)
+            case 'number': // 数字
+                return /^[0-9]$/.test(str)
+            case 'english': // 英文
+                return /^[a-zA-Z]+$/.test(str)
+            case 'chinese': // 中文
+                return /^[\u4E00-\u9FA5]+$/.test(str)
+            case 'lower': // 小写
+                return /^[a-z]+$/.test(str)
+            case 'upper': // 大写
+                return /^[A-Z]+$/.test(str)
+            case 'HTML': // HTML标记
+                return /<("[^"]*"|'[^']*'|[^'">])*>/.test(str)
+            default:
+                return true
+        }
+    },
+    /**
+     *  字符串大小写转换 type:  1:首字母大写  2：首页母小写  3：大小写转换  4：全部大写  5：全部小写
+     *
+     * @param {*} str
+     * @param {*} type
+     * @returns {*}
+     */
+    changeCase(str, type) {
+        type = type || 4
+        switch (type) {
+            case 1:
+                return str.replace(/\b\w+\b/g, function (word) {
+                    return word.substring(0, 1).toUpperCase() + word.substring(1).toLowerCase()
+                })
+            case 2:
+                return str.replace(/\b\w+\b/g, function (word) {
+                    return word.substring(0, 1).toLowerCase() + word.substring(1).toUpperCase()
+                })
+            case 3:
+                return str
+                    .split('')
+                    .map(function (word) {
+                        if (/[a-z]/.test(word)) {
+                            return word.toUpperCase()
+                        } else {
+                            return word.toLowerCase()
+                        }
+                    })
+                    .join('')
+            case 4:
+                return str.toUpperCase()
+            case 5:
+                return str.toLowerCase()
+            default:
+                return str
+        }
+    },
+    /**
+     * 处理字符串模板
+     * eg: tag`${abc}`
+     * @param {*} strArray
+     * @param {*} args
+     * @returns {*}
+     */
+    tag(strArray, ...args) {
+        args = args.map((val) => {
+            switch (CommUtils.getDataType(val)) {
+                case 'Object':
+                    return val || '{}'
+                case 'Array':
+                    return val || '[]'
+                default:
+                    return val || ''
+            }
+        })
+        return strArray.reduce((prev, next, index) => `${prev}${args[index - 1]}${next}`)
+    },
+    /**
+     * 获取字符串字节长度
+     * @param {*} str
+     * @returns {*}
+     */
+    getByteLength(str) {
+        return str.replace(/[\u0391-\uFFE5]/g, 'aa').length
+    },
+    /**
+     * 根据字节长度截取字符串
+     * @param {*} str
+     * @param {*} n
+     * @returns {*}
+     */
+    subStringByte(str, start, n) {
+        var r = /[^\x00-\xff]/g
+        if (str.replace(r, 'mm').length <= n) {
+            return str
+        }
+        var m = Math.floor(n / 2)
+        for (var i = m; i < str.length; i++) {
+            let sub = str.substring(start, i)
+            if (sub.replace(r, 'mm').length >= n) {
+                return sub
+            }
+        }
+        return str
+    },
+}

package/src/utils/index.js

@@ -0,0 +1,13 @@
+export { default as AnimateUtils } from "./AnimateUtils";
+export { default as ArrayUtils } from "./ArrayUtils";
+export { default as BrowserUtils } from "./BrowserUtils";
+export { default as Cookie } from "./Cookie";
+export { default as CoordsUtils } from "./CoordsUtils";
+export { default as DateUtils } from "./DateUtils";
+export { default as DomUtils } from "./DomUtils";
+export { default as GeoUtils } from "./GeoUtils";
+export { default as FileUtils } from "./FileUtils";
+export { default as MathUtils } from "./MathUtils";
+export { default as OptimizeUtils } from "./OptimizeUtils";
+export { default as StringUtils } from "./StringUtils";
+export { default as Utils } from "./CommUtils";

package/webpack.config.js

@@ -0,0 +1,70 @@
+var path = require('path')
+var webpack = require('webpack')
+const { CleanWebpackPlugin } = require('clean-webpack-plugin')
+
+module.exports = {
+    entry: './src/index.js',
+    output: {
+        path: path.resolve(__dirname, './dist'),
+        publicPath: '/dist/',
+        filename: 'resource.min.js',
+        library: 'Gis',
+        libraryTarget: 'umd',
+        umdNamedDefine: true,
+    },
+    module: {
+        rules: [
+            {
+                test: /\.css$/,
+                use: ['vue-style-loader', 'css-loader'],
+            },
+            {
+                test: /\.vue$/,
+                loader: 'vue-loader',
+                options: {
+                    loaders: {},
+                    // other vue-loader options go here
+                },
+            },
+            {
+                test: /\.js$/,
+                loader: 'babel-loader',
+                exclude: /node_modules/,
+            },
+            {
+                test: /\.(png|jpg|gif|svg)$/,
+                loader: 'url-loader',
+                options: {
+                    limit: 100000,
+                },
+            },
+        ],
+    },
+    externals: {
+        mqtt: 'mqtt',
+    },
+    plugins: [
+        new CleanWebpackPlugin(),
+        new webpack.LoaderOptionsPlugin({
+            minimize: true,
+        }),
+    ],
+    resolve: {
+        alias: {
+            vue$: 'vue/dist/vue.esm.js',
+        },
+        extensions: ['*', '.js', '.vue', '.json'],
+    },
+    devServer: {
+        historyApiFallback: true,
+        noInfo: true,
+        overlay: true,
+    },
+    performance: {
+        hints: false,
+    },
+    devtool: 'none',
+    optimization: {
+        minimize: false,
+    },
+}