gis-common 2.2.2 → 2.2.4

package/src/utils/GeoUtils.js

@@ -1,242 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,135 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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,
-    },
-}